[cfe/ffi] Test Finalizables in extension methods

`Finalizable`s with extension methods work by virtue of being
desugared into static methods and the `Finalizable`s being normal
arguments.

If we ever change the representation of extension methods,
`Finalizable`s would need to be treated specially. This test will
catch that.

TEST=pkg/vm/test/transformations/ffi_test.dart

Bug: #49643 (comment)

Change-Id: I68cfbc098386a88495d37417c6eb7295b89bfb95
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/255123
Reviewed-by: Tess Strickland <[email protected]>
Commit-Queue: Daco Harkes <[email protected]>

Author: dcharkes

pkg/vm/testcases/transformations/ffi/finalizable_extension_method.dart

@@ -0,0 +1,31 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// @dart=2.16
+
+import 'dart:ffi';
+
+class Foo implements Finalizable {}
+
+void main() {
+  final foo = Foo();
+  foo.bar();
+  Object().baz(foo);
+}
+
+extension on Finalizable {
+  int bar() {
+    print('123');
+    // Should generate a fence for `this` before returning 4.
+    return 4;
+  }
+}
+
+extension on Object {
+  int baz(Foo foo) {
+    print('456');
+    // Should generate a fence for `foo` before returning 5.
+    return 5;
+  }
+}

pkg/vm/testcases/transformations/ffi/finalizable_extension_method.dart.expect

@@ -0,0 +1,59 @@
+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";
+
+class Foo extends core::Object implements ffi::Finalizable {
+  synthetic constructor •() → self::Foo
+    : super core::Object::•()
+    ;
+}
+extension _extension#0 on ffi::Finalizable {
+  method bar = self::_extension#0|bar;
+  tearoff bar = self::_extension#0|get#bar;
+}
+extension _extension#1 on core::Object {
+  method baz = self::_extension#1|baz;
+  tearoff baz = self::_extension#1|get#baz;
+}
+static method main() → void {
+  final self::Foo foo = new self::Foo::•();
+  self::_extension#0|bar(foo);
+  self::_extension#1|baz(new core::Object::•(), foo);
+  _in::reachabilityFence(foo);
+}
+static method _extension#0|bar(lowered final ffi::Finalizable #this) → core::int {
+  core::print("123");
+  return block {
+    final core::int :expressionValueWrappedFinalizable = 4;
+    _in::reachabilityFence(#this);
+  } =>:expressionValueWrappedFinalizable;
+}
+static method _extension#0|get#bar(lowered final ffi::Finalizable #this) → () → core::int {
+  return block {
+    final () → core::int :expressionValueWrappedFinalizable = () → core::int {
+      return block {
+        final core::int :expressionValueWrappedFinalizable = self::_extension#0|bar(#this);
+        _in::reachabilityFence(#this);
+      } =>:expressionValueWrappedFinalizable;
+    };
+    _in::reachabilityFence(#this);
+  } =>:expressionValueWrappedFinalizable;
+}
+static method _extension#1|baz(lowered final core::Object #this, self::Foo foo) → core::int {
+  core::print("456");
+  return block {
+    final core::int :expressionValueWrappedFinalizable = 5;
+    _in::reachabilityFence(foo);
+  } =>:expressionValueWrappedFinalizable;
+}
+static method _extension#1|get#baz(lowered final core::Object #this) → (self::Foo) → core::int
+  return (self::Foo foo) → core::int {
+    return block {
+      final core::int :expressionValueWrappedFinalizable = self::_extension#1|baz(#this, foo);
+      _in::reachabilityFence(foo);
+    } =>:expressionValueWrappedFinalizable;
+  };