Adding BindingsIr

This is a reimangining of the ComponentInterface, modeled after a
compiler pipeline.  The differences are:

- Data-oriented API.  It has `pub` fields rather than getter methods.
- Tree-like.  Fields represent nodes in the tree.  You can understand
  `BindingsIr` by following the fields.
- Data is stored directly in the nodes, for example types now have an
  `is_used_as_error` field instead of having to lookup the type name in
  `ComponentInterface::errors`.
- Each node contains a `LanguageData` container.  Bindings generators
  will put language-specific data in here as part of the bindings IR
  specialization process.  For example: `type_name`, `ffi_converter` and
  `ffi_type_name`.  To accomplish this, `Type`, `FfiType` and `Literal` are
  now structs, which store a `kind` enum.
- It tries to make a stronger distinction between definitions and
  references to those definitions.
- Type and FFI types are sorted in dependency order.  This replaces the
  the Python bindings code that does something similar to avoid forward
  references.

Languages can opt-in to the new API by converting the
`ComponentInterface` into a `BindingsIr`. At some point we start
converting the metadata directly to `BindingsIr` and remove a ton of
ComponentInterface code. Let's make sure to give external bindings
authors time to move to the new system.

Author: bendk

uniffi_bindgen/src/interface/ir/from_ci.rs

@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+mod from_ci;
+mod nodes;
+mod sort;
+
+pub use nodes::*;
+
+// Note: the interface code is currently in a bit of a transition state. Most languages are still
+// using the `ComponentInterface` to render their bindings, but we plan to switch them over to this
+// system.
+//
+// Once we do that, we can rework the metadata code to generate a `BindingsIr` directly,
+// delete a ton of the older code, and consider folding the contents of the `ir` module into
+// `interface`.

uniffi_bindgen/src/interface/ir/mod.rs

@@ -2,57 +2,60 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use uniffi_meta::EnumShape;
+
+use super::{Literal, Type};
+
 /// Represents a "data class" style object, for passing around complex values.
 ///
 /// In the FFI these are represented as a byte buffer, which one side explicitly
 /// serializes the data into and the other serializes it out of. So I guess they're
 /// kind of like "pass by clone" values.
-#[derive(Debug, Clone, PartialEq, Eq, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Record {
-    pub(super) name: String,
-    pub(super) module_path: String,
-    pub(super) remote: bool,
-    pub(super) fields: Vec<Field>,
-    #[checksum_ignore]
-    pub(super) docstring: Option<String>,
+    pub name: String,
+    pub module_path: String,
+    pub remote: bool,
+    pub fields: Vec<Field>,
+    pub docstring: Option<String>,
+    pub self_type: Type,
 }
 
 // Represents an individual field on a Record.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Field {
-    pub(super) name: String,
-    pub(super) type_: Type,
-    pub(super) default: Option<Literal>,
-    #[checksum_ignore]
-    pub(super) docstring: Option<String>,
+    pub name: String,
+    pub ty: Type,
+    pub default: Option<Literal>,
+    pub docstring: Option<String>,
 }
 
 /// Represents an enum with named variants, each of which may have named
 /// and typed fields.
 ///
 /// Enums are passed across the FFI by serializing to a bytebuffer, with a
 /// i32 indicating the variant followed by the serialization of each field.
-#[derive(Debug, Clone, PartialEq, Eq, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Enum {
-    pub(super) name: String,
-    pub(super) module_path: String,
-    pub(super) remote: bool,
-    pub(super) discr_type: Option<Type>,
-    pub(super) variants: Vec<Variant>,
-    pub(super) shape: EnumShape,
-    pub(super) non_exhaustive: bool,
-    #[checksum_ignore]
-    pub(super) docstring: Option<String>,
+    pub name: String,
+    pub module_path: String,
+    pub remote: bool,
+    pub discr_type: Option<Type>,
+    pub variants: Vec<Variant>,
+    pub shape: EnumShape,
+    pub non_exhaustive: bool,
+    pub docstring: Option<String>,
+    pub self_type: Type,
 }
 
 /// Represents an individual variant in an Enum.
 ///
 /// Each variant has a name and zero or more fields.
-#[derive(Debug, Clone, Default, PartialEq, Eq, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Variant {
-    pub(super) name: String,
-    pub(super) discr: Option<Literal>,
-    pub(super) fields: Vec<Field>,
-    #[checksum_ignore]
-    pub(super) docstring: Option<String>,
+    pub name: String,
+    pub discr: Literal,
+    pub fields: Vec<Field>,
+    pub enum_shape: EnumShape,
+    pub docstring: Option<String>,
 }

uniffi_bindgen/src/interface/ir/nodes/dataclasses.rs

@@ -2,11 +2,14 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
-/// An Ffi definition
+/// Represents an Ffi definition
 #[derive(Debug, Clone)]
 pub enum FfiDefinition {
+    // Scaffolding function exported in the library
     Function(FfiFunction),
-    CallbackFunction(FfiCallbackFunction),
+    // Function type, for function pointers
+    FunctionType(FfiFunctionType),
+    // FFI struct definition
     Struct(FfiStruct),
 }
 
@@ -18,52 +21,53 @@ pub enum FfiDefinition {
 /// some built-in `FfiFunction` helpers for use in the foreign language bindings.
 #[derive(Debug, Clone)]
 pub struct FfiFunction {
-    pub(super) name: String,
-    pub(super) is_async: bool,
-    pub(super) arguments: Vec<FfiArgument>,
-    pub(super) return_type: Option<FfiType>,
-    pub(super) has_rust_call_status_arg: bool,
+    pub name: String,
+    pub is_async: bool,
+    pub arguments: Vec<FfiArgument>,
+    pub return_type: Option<FfiType>,
+    pub has_rust_call_status_arg: bool,
     /// Used by C# generator to differentiate the free function and call it with void*
     /// instead of C# `SafeHandle` type. See <https://github.com/mozilla/uniffi-rs/pull/1488>.
-    pub(super) is_object_free_function: bool,
+    pub is_object_free_function: bool,
 }
 
 /// Represents an "extern C"-style callback function
 ///
 /// These are defined in the foreign code and passed to Rust as a function pointer.
-#[derive(Debug, Default, Clone)]
-pub struct FfiCallbackFunction {
+#[derive(Debug, Clone)]
+pub struct FfiFunctionType {
     // Name for this function type. This matches the value inside `FfiType::Callback`
-    pub(super) name: String,
-    pub(super) arguments: Vec<FfiArgument>,
-    pub(super) return_type: Option<FfiType>,
-    pub(super) has_rust_call_status_arg: bool,
+    pub name: String,
+    pub arguments: Vec<FfiArgument>,
+    pub return_type: Option<FfiType>,
+    pub has_rust_call_status_arg: bool,
 }
 
-/// Represents a repr(C) struct used in the FFI
+/// Represents a repr(C) struct
 #[derive(Debug, Default, Clone)]
 pub struct FfiStruct {
-    pub(super) name: String,
-    pub(super) fields: Vec<FfiField>,
+    pub name: String,
+    pub fields: Vec<FfiField>,
 }
 
 /// Represents a field of an [FfiStruct]
 #[derive(Debug, Clone)]
 pub struct FfiField {
-    pub(super) name: String,
-    pub(super) type_: FfiType,
+    pub name: String,
+    pub ty: FfiType,
 }
 
 /// Represents an argument to an FFI function.
 ///
 /// Each argument has a name and a type.
 #[derive(Debug, Clone)]
 pub struct FfiArgument {
-    pub(super) name: String,
-    pub(super) type_: FfiType,
+    pub name: String,
+    pub ty: FfiType,
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+/// Represents an FFI type
+#[derive(Debug, Clone)]
 pub enum FfiType {
     // N.B. there are no booleans at this layer, since they cause problems for JNA.
     UInt8,
@@ -84,17 +88,15 @@ pub enum FfiType {
     /// A byte buffer allocated by rust, and owned by whoever currently holds it.
     /// If you've got one of these, you must either call the appropriate rust function to free it
     /// or pass it to someone that will.
-    /// If the inner option is Some, it is the name of the external type. The bindings may need
-    /// to use this name to import the correct RustBuffer for that type.
     RustBuffer(Option<ExternalFfiMetadata>),
     /// A borrowed reference to some raw bytes owned by foreign language code.
     /// The provider of this reference must keep it alive for the duration of the receiving call.
     ForeignBytes,
-    /// Pointer to a callback function.  The inner value which matches one of the callback
-    /// definitions in [crate::ComponentInterface::ffi_definitions].
-    Callback(String),
+    /// Function pointer.  The inner value is the name of one of the `FfiFunctionType` definitions
+    /// in the IR.
+    FunctionPointer(String),
     /// Pointer to a FFI struct (e.g. a VTable).  The inner value matches one of the struct
-    /// definitions in [crate::ComponentInterface::ffi_definitions].
+    /// definitions in the IR.
     Struct(String),
     /// Opaque 64-bit handle
     ///
@@ -108,3 +110,42 @@ pub enum FfiType {
     /// Opaque pointer
     VoidPointer,
 }
+
+/// Set for RustBuffers for external types.  These are usually defined in a different generated
+/// bindings module.
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ExternalFfiMetadata {
+    /// FIXME: only store one of these, we currently need to store them both for weird historical
+    /// reasons.
+    pub module_path: String,
+    pub namespace: String,
+}
+
+/// Ffi function to check a checksum for an item in the interface
+///
+/// Bindings generators should call each of these functions and check that they return the
+/// `checksum` value.
+#[derive(Debug, Clone)]
+pub struct ChecksumCheck {
+    pub func: FfiFunctionRef,
+    pub checksum: u16,
+}
+
+/// Reference to an scaffolding function
+#[derive(Debug, Clone)]
+pub struct FfiFunctionRef {
+    pub name: String,
+    /// Used by C# generator to differentiate the free function and call it with void*
+    /// instead of C# `SafeHandle` type. See <https://github.com/mozilla/uniffi-rs/pull/1488>.
+    pub is_object_free_function: bool,
+}
+
+impl FfiDefinition {
+    pub fn name(&self) -> &str {
+        match self {
+            Self::Function(f) => &f.name,
+            Self::FunctionType(f) => &f.name,
+            Self::Struct(s) => &s.name,
+        }
+    }
+}

uniffi_bindgen/src/interface/ir/nodes/ffi.rs

@@ -2,44 +2,58 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+use super::{FfiFunctionRef, FfiType, Literal, Type};
+
 /// Represents a standalone function.
 ///
 /// Each `Function` corresponds to a standalone function in the rust module,
 /// and has a corresponding standalone function in the foreign language bindings.
 ///
 /// In the FFI, this will be a standalone function with appropriately lowered types.
-#[derive(Debug, Clone, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Function {
-    pub(super) name: String,
-    pub(super) module_path: String,
-    pub(super) is_async: bool,
-    pub(super) arguments: Vec<Argument>,
-    pub(super) return_type: Option<Type>,
-    // We don't include the FFIFunc in the hash calculation, because:
-    //  - it is entirely determined by the other fields,
-    //    so excluding it is safe.
-    //  - its `name` property includes a checksum derived from the very
-    //    hash value we're trying to calculate here, so excluding it
-    //    avoids a weird circular dependency in the calculation.
-    #[checksum_ignore]
-    pub(super) ffi_func: FfiFunction,
-    #[checksum_ignore]
-    pub(super) docstring: Option<String>,
-    pub(super) throws: Option<Type>,
-    pub(super) checksum_fn_name: String,
-    // Force a checksum value, or we'll fallback to the trait.
-    #[checksum_ignore]
-    pub(super) checksum: Option<u16>,
+    pub name: String,
+    pub docstring: Option<String>,
+    pub module_path: String,
+    pub callable: Callable,
+}
+
+/// Callable data, this is shared between functions, methods, and constructors.
+#[derive(Debug, Clone)]
+pub struct Callable {
+    pub kind: CallableKind,
+    pub async_data: Option<AsyncData>,
+    pub arguments: Vec<Argument>,
+    pub return_type: Option<Type>,
+    pub throws_type: Option<Type>,
+    pub ffi_func: FfiFunctionRef,
+}
+
+#[derive(Debug, Clone)]
+pub enum CallableKind {
+    Function,
+    Method,
+    VTableMethod,
+    Constructor { primary: bool },
+}
+
+#[derive(Debug, Clone)]
+pub struct AsyncData {
+    pub ffi_rust_future_poll: FfiFunctionRef,
+    pub ffi_rust_future_complete: FfiFunctionRef,
+    pub ffi_rust_future_free: FfiFunctionRef,
+    /// The FFI struct to pass to the completion function for callback interface methods
+    pub foreign_future_result_type: FfiType,
 }
 
 /// Represents an argument to a function/constructor/method call.
 ///
 /// Each argument has a name and a type, along with some optional metadata.
-#[derive(Debug, Clone, Checksum)]
+#[derive(Debug, Clone)]
 pub struct Argument {
-    pub(super) name: String,
-    pub(super) type_: Type,
-    pub(super) by_ref: bool,
-    pub(super) optional: bool,
-    pub(super) default: Option<Literal>,
+    pub name: String,
+    pub ty: Type,
+    pub by_ref: bool,
+    pub optional: bool,
+    pub default: Option<Literal>,
 }