[pkg/vm] Add tool for generating DartEngine shims from entry points.

This is an initial cut of a tool for automatically creating shims for
C/C++ programs using the entry point annotations in Dart code. The tool
has two required arguments:

* the .dill file containing the kernel representation of the Dart code
* the base path of the header and implementation files to create

With a base path of 'dir/name', the header file is created as
'dir/name.h' and the implementation file is created as 'dir/name.cc'.
In addition, 'dir/name.h' is used as a basis for creating a
#ifndef/#define/#endif header guard around the header contents.


The created shims are specific to a single package, either

* a user-specified package, provided via '-p'/'--package', or
* the package of the main method

If the user does not specify a package and there is no main method
in the .dill file, the tool fails.


Each shim takes the following arguments in order when applicable:

* the isolate in which to perform the requested operation,
* the instantiated type of the generic class (for invoking, setting, or
  getting constructors, static methods, and static fields)
* the instance (for invoking, getting, or setting instance methods and
  fields)
* the type arguments (for retrieving nullable or non-nullable
  instantiated types of a generic class)
* the arguments (for invoking, setting, or getting constructors,
  methods, and fields)


The generated shims:

* cache the package library, types for non-generic classes, and
  types for generic classes instantiated with default type arguments.
  The cached persistent handles are cleared if any of the methods
  are called with a different isolate from the one used to populate
  the cache.
* automatically handle conversions between C int64_t <=> Dart int
  and C double <=> Dart double.


By default, shims are not created for allocation or initializing
uninitialized instances. To create such shims, use the '-u' command
line argument.


Currently, shims are not created for methods that take optional
or named arguments. To report an error if a shim cannot be created
for any entry points, use the '-e' command line argument.

TEST=tests/standalone/embedder_samples_test

Change-Id: Ibdf3b52d900ba98038528178485f295c5868ac9d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/410500
Reviewed-by: Ivan Inozemtsev <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>

Author: sstrickl

pkg/vm/lib/embedder/collector.dart

@@ -0,0 +1,136 @@
+// Copyright (c) 2025, 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:kernel/ast.dart';
+import 'package:kernel/core_types.dart' show CoreTypes;
+
+import 'shims.dart';
+
+enum EntryPointRole {
+  // Dart_New (constructors) / Dart_Allocate (classes)
+  allocation,
+  // Dart_Invoke (invocable methods as well as invocable (function-valued)
+  // fields and getters)
+  call,
+  // Dart_GetField (non-getter methods)
+  closure,
+  // Dart_GetClass (default type arguments for parameterized types)
+  class_,
+  // Dart_GetField (getter methods and fields)
+  getter,
+  // Dart_InvokeConstructor
+  initialization,
+  // Dart_SetField (setter methods and fields)
+  setter,
+  // Dart_NonNullableType
+  nonNullableType,
+  // Dart_NullableType
+  nullableType,
+}
+
+class EntryPointShimCollector {
+  final CoreTypes _coreTypes;
+  final bool _errorOnUnhandledEntryPoints;
+  final roles = <Reference, Set<EntryPointFunctionShim>>{};
+
+  EntryPointShimCollector(this._coreTypes, this._errorOnUnhandledEntryPoints);
+
+  bool _hasUnhandledFeatures(NamedNode node, FunctionType type) {
+    if (type.namedParameters.isNotEmpty) {
+      if (_errorOnUnhandledEntryPoints) {
+        throw ArgumentError("$node: named parameters are not handled");
+      }
+      return true;
+    }
+    if (type.positionalParameters.length !=
+        type.requiredPositionalParameterCount) {
+      if (_errorOnUnhandledEntryPoints) {
+        throw ArgumentError("$node: optional parameters are not handled");
+      }
+      return true;
+    }
+    if (type.typeParameters.isNotEmpty) {
+      if (_errorOnUnhandledEntryPoints) {
+        throw ArgumentError("$node: generic methods are not handled");
+      }
+      return true;
+    }
+    return false;
+  }
+
+  void add(Reference reference, EntryPointRole role) {
+    final node = reference.node;
+    late final EntryPointFunctionShim shim;
+    switch (role) {
+      case EntryPointRole.class_:
+        shim = EntryPointClassShim.fromClass(node as Class, _coreTypes);
+        break;
+      case EntryPointRole.nonNullableType:
+        shim = EntryPointNonNullableTypeShim.fromClass(
+          node as Class,
+          _coreTypes,
+        );
+        break;
+      case EntryPointRole.nullableType:
+        shim = EntryPointNullableTypeShim.fromClass(node as Class, _coreTypes);
+        break;
+      case EntryPointRole.allocation:
+        if (node is Constructor) {
+          if (_hasUnhandledFeatures(
+            node,
+            EntryPointNewShim.functionType(node),
+          )) {
+            return;
+          }
+          shim = EntryPointNewShim.fromConstructor(node, _coreTypes);
+        } else {
+          shim = EntryPointAllocationShim.fromClass(node as Class, _coreTypes);
+        }
+        break;
+      case EntryPointRole.call:
+        final member = node as Member;
+        if (_hasUnhandledFeatures(
+          member,
+          EntryPointCallShim.functionType(member),
+        )) {
+          return;
+        }
+        shim = EntryPointCallShim.fromMember(member, _coreTypes);
+        break;
+      case EntryPointRole.closure:
+        shim = EntryPointClosureShim.fromProcedure(
+          node as Procedure,
+          _coreTypes,
+        );
+        break;
+      case EntryPointRole.getter:
+        shim = EntryPointGetterShim.fromMember(node as Member, _coreTypes);
+        break;
+      case EntryPointRole.initialization:
+        final c = node as Constructor;
+        if (_hasUnhandledFeatures(
+          c,
+          EntryPointInitializationShim.functionType(c),
+        )) {
+          return;
+        }
+        shim = EntryPointInitializationShim.fromConstructor(c, _coreTypes);
+        break;
+      case EntryPointRole.setter:
+        shim = EntryPointSetterShim.fromMember(node as Member, _coreTypes);
+        break;
+    }
+    roles.putIfAbsent(reference, () => {}).add(shim);
+  }
+
+  void addAll(Reference reference, Iterable<EntryPointRole> it) =>
+      it.forEach((role) => add(reference, role));
+
+  Iterable<Reference> get keys => roles.keys;
+  Iterable<MapEntry<Reference, Set<EntryPointFunctionShim>>> get entries =>
+      roles.entries;
+  Set<EntryPointFunctionShim>? operator [](Reference reference) =>
+      roles[reference];
+  bool containsKey(Reference reference) => roles.containsKey(reference);
+}