Version 2.19.0-436.0.dev

Merge 78fc03c into dev

Author: Dart CI

CHANGELOG.md

@@ -89,6 +89,13 @@
 [#34233]: https://github.com/dart-lang/sdk/issues/34233
 [`ServiceExtensionResponse`]: https://api.dart.dev/stable/2.17.6/dart-developer/ServiceExtensionResponse-class.html#constants
 
+#### `dart:ffi`
+
+- **Breaking change** [#49935][]:  The runtime type argument of `Pointer` has
+  changed to `Never` in preparation of completely removing the runtime type
+  argument. `Pointer.toString` has changed to not report any type argument.
+
+[#49935]: https://github.com/dart-lang/sdk/issues/49935
 
 #### `dart:html`
 

pkg/analyzer/lib/src/dart/analysis/file_state.dart

@@ -1244,6 +1244,10 @@ class FileSystemState {
     return _pathToFile[file.path];
   }
 
+  FileState? getExistingFromPath(String path) {
+    return _pathToFile[path];
+  }
+
   /// Return the [FileState] for the given absolute [path]. The returned file
   /// has the last known state since if was last refreshed.
   /// TODO(scheglov) Merge with [getFileForPath2].

pkg/analyzer/lib/src/dart/analysis/search.dart

@@ -722,8 +722,7 @@ class SearchedFiles {
 
   bool add(String path, Search search) {
     final fsState = search._driver.fsState;
-    final file = fsState.resourceProvider.getFile(path);
-    final fileState = fsState.getExisting(file);
+    final fileState = fsState.getExistingFromPath(path);
     if (fileState == null) {
       return false;
     }

runtime/lib/ffi.cc

@@ -122,7 +122,6 @@ DEFINE_NATIVE_ENTRY(Ffi_nativeCallbackFunction, 1, 2) {
 }
 
 DEFINE_NATIVE_ENTRY(Ffi_pointerFromFunction, 1, 1) {
-  GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
   const Function& function =
       Function::CheckedHandle(zone, arguments->NativeArg0());
 
@@ -164,7 +163,7 @@ DEFINE_NATIVE_ENTRY(Ffi_pointerFromFunction, 1, 1) {
   }
 #endif
 
-  return Pointer::New(type_arg, entry_point);
+  return Pointer::New(entry_point);
 }
 
 DEFINE_NATIVE_ENTRY(DartNativeApiFunctionPointer, 0, 1) {

runtime/lib/ffi_dynamic_library.cc

@@ -180,8 +180,6 @@ DEFINE_NATIVE_ENTRY(Ffi_dl_executableLibrary, 0, 0) {
 }
 
 DEFINE_NATIVE_ENTRY(Ffi_dl_lookup, 1, 2) {
-  GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
-
   GET_NON_NULL_NATIVE_ARGUMENT(DynamicLibrary, dlib, arguments->NativeArgAt(0));
   GET_NON_NULL_NATIVE_ARGUMENT(String, argSymbolName,
                                arguments->NativeArgAt(1));
@@ -197,7 +195,7 @@ DEFINE_NATIVE_ENTRY(Ffi_dl_lookup, 1, 2) {
     free(error);
     Exceptions::ThrowArgumentError(msg);
   }
-  return Pointer::New(type_arg, pointer);
+  return Pointer::New(pointer);
 }
 
 DEFINE_NATIVE_ENTRY(Ffi_dl_getHandle, 0, 1) {
@@ -291,8 +289,7 @@ static intptr_t FfiResolve(Dart_Handle asset_handle,
 
 // Bootstrap to get the FFI Native resolver through a `native` call.
 DEFINE_NATIVE_ENTRY(Ffi_GetFfiNativeResolver, 1, 0) {
-  GET_NATIVE_TYPE_ARGUMENT(type_arg, arguments->NativeTypeArgAt(0));
-  return Pointer::New(type_arg, reinterpret_cast<intptr_t>(FfiResolve));
+  return Pointer::New(reinterpret_cast<intptr_t>(FfiResolve));
 }
 
 #endif  // defined(USING_SIMULATOR) ||                                         \

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -1324,29 +1324,15 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
       body +=
           Box(LoadIndexedInstr::RepresentationOfArrayElement(typed_data_cid));
       if (kind == MethodRecognizer::kFfiLoadPointer) {
-        const auto class_table = thread_->isolate_group()->class_table();
-        ASSERT(class_table->HasValidClassAt(kPointerCid));
         const auto& pointer_class =
-            Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
-
-        // We find the reified type to use for the pointer allocation.
-        //
-        // Call sites to this recognized method are guaranteed to pass a
-        // Pointer<Pointer<X>> as RawParameterVariable(0). This function
-        // will return a Pointer<X> object - for which we inspect the
-        // reified type on the argument.
-        //
-        // The following is safe to do, as (1) we are guaranteed to have a
-        // Pointer<Pointer<X>> as argument, and (2) the bound on the pointer
-        // type parameter guarantees X is an interface type.
+            Class::ZoneHandle(Z, IG->object_store()->ffi_pointer_class());
+        const auto& type_arguments = TypeArguments::ZoneHandle(
+            Z, IG->object_store()->type_argument_never());
+
+        // We do not reify Pointer type arguments
         ASSERT(function.NumTypeParameters() == 1);
         LocalVariable* address = MakeTemporary();
-        body += LoadLocal(parsed_function_->RawParameterVariable(0));
-        body += LoadNativeField(
-            Slot::GetTypeArgumentsSlotFor(thread_, pointer_class));
-        body += LoadNativeField(Slot::GetTypeArgumentsIndexSlot(
-            thread_, Pointer::kNativeTypeArgPos));
-        body += LoadNativeField(Slot::Type_arguments());
+        body += Constant(type_arguments);
         body += AllocateObject(TokenPosition::kNoSource, pointer_class, 1);
         LocalVariable* pointer = MakeTemporary();
         body += LoadLocal(pointer);
@@ -1381,37 +1367,6 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
       LocalVariable* arg_offset = parsed_function_->RawParameterVariable(1);
       LocalVariable* arg_value = parsed_function_->RawParameterVariable(2);
 
-      if (kind == MethodRecognizer::kFfiStorePointer) {
-        // Do type check before anything untagged is on the stack.
-        const auto class_table = thread_->isolate_group()->class_table();
-        ASSERT(class_table->HasValidClassAt(kPointerCid));
-        const auto& pointer_class =
-            Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
-        const auto& pointer_type_param =
-            TypeParameter::ZoneHandle(pointer_class.TypeParameterAt(0));
-
-        // But we type check it as a method on a generic class at runtime.
-        body += LoadLocal(arg_value);          // value.
-        body += Constant(pointer_type_param);  // dst_type.
-        // We pass the Pointer type argument as instantiator_type_args.
-        //
-        // Call sites to this recognized method are guaranteed to pass a
-        // Pointer<Pointer<X>> as RawParameterVariable(0). This function
-        // will takes a Pointer<X> object - for which we inspect the
-        // reified type on the argument.
-        //
-        // The following is safe to do, as (1) we are guaranteed to have a
-        // Pointer<Pointer<X>> as argument, and (2) the bound on the pointer
-        // type parameter guarantees X is an interface type.
-        body += LoadLocal(arg_pointer);
-        body += CheckNullOptimized(String::ZoneHandle(Z, function.name()));
-        body += LoadNativeField(
-            Slot::GetTypeArgumentsSlotFor(thread_, pointer_class));
-        body += NullConstant();  // function_type_args.
-        body += AssertAssignable(TokenPosition::kNoSource, Symbols::Empty());
-        body += Drop();
-      }
-
       ASSERT_EQUAL(function.NumParameters(), 3);
       body += LoadLocal(arg_offset);
       body += CheckNullOptimized(String::ZoneHandle(Z, function.name()));
@@ -1448,14 +1403,14 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
       body += NullConstant();
     } break;
     case MethodRecognizer::kFfiFromAddress: {
-      const auto class_table = thread_->isolate_group()->class_table();
-      ASSERT(class_table->HasValidClassAt(kPointerCid));
       const auto& pointer_class =
-          Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
+          Class::ZoneHandle(Z, IG->object_store()->ffi_pointer_class());
+      const auto& type_arguments = TypeArguments::ZoneHandle(
+          Z, IG->object_store()->type_argument_never());
 
       ASSERT(function.NumTypeParameters() == 1);
       ASSERT_EQUAL(function.NumParameters(), 1);
-      body += LoadLocal(parsed_function_->RawTypeArgumentsVariable());
+      body += Constant(type_arguments);
       body += AllocateObject(TokenPosition::kNoSource, pointer_class, 1);
       body += LoadLocal(MakeTemporary());  // Duplicate Pointer.
       body += LoadLocal(parsed_function_->RawParameterVariable(0));  // Address.
@@ -4306,15 +4261,17 @@ Fragment FlowGraphBuilder::NativeReturn(
   return Fragment(instr).closed();
 }
 
-Fragment FlowGraphBuilder::FfiPointerFromAddress(const Type& result_type) {
+Fragment FlowGraphBuilder::FfiPointerFromAddress() {
   LocalVariable* address = MakeTemporary();
   LocalVariable* result = parsed_function_->expression_temp_var();
 
-  Class& result_class = Class::ZoneHandle(Z, result_type.type_class());
+  Class& result_class =
+      Class::ZoneHandle(Z, IG->object_store()->ffi_pointer_class());
   // This class might only be instantiated as a return type of ffi calls.
   result_class.EnsureIsFinalized(thread_);
 
-  TypeArguments& args = TypeArguments::ZoneHandle(Z, result_type.arguments());
+  TypeArguments& args =
+      TypeArguments::ZoneHandle(Z, IG->object_store()->type_argument_never());
 
   // A kernel transform for FFI in the front-end ensures that type parameters
   // do not appear in the type arguments to a any Pointer classes in an FFI
@@ -4656,8 +4613,7 @@ Fragment FlowGraphBuilder::FfiConvertPrimitiveToDart(
   Fragment body;
   if (marshaller.IsPointer(arg_index)) {
     body += Box(kUnboxedFfiIntPtr);
-    body += FfiPointerFromAddress(
-        Type::CheckedHandle(Z, marshaller.CType(arg_index)));
+    body += FfiPointerFromAddress();
   } else if (marshaller.IsHandle(arg_index)) {
     body += UnwrapHandle();
   } else if (marshaller.IsVoid(arg_index)) {

runtime/vm/compiler/frontend/kernel_to_il.h

@@ -285,8 +285,8 @@ class FlowGraphBuilder : public BaseFlowGraphBuilder {
   // Converts 0 to false and the rest to true.
   Fragment IntToBool();
 
-  // Creates an ffi.Pointer holding a given address (TOS).
-  Fragment FfiPointerFromAddress(const Type& result_type);
+  // Creates an ffi.Pointer holding a given address.
+  Fragment FfiPointerFromAddress();
 
   // Pushes an (unboxed) bogus value returned when a native -> Dart callback
   // throws an exception.