wasmtime component: get InstancePre from Instance (#10621)

* component::InstancePre contains the types::Component with imported resource types

types::Component can be used to create an InstanceType (also added as a
hidden method). The construction of InstancePre in the Linker calculates
this information already, and the types::Compoonent is just storing Arcs
to this information.

* Add hidden Instance::instance_pre method

which retrieves an InstancePre corresponding to an Instance.

All of the information needed to compute the InstancePre is already
present in the Store under the Instances's index.

This method is pub but doc(hidden) because it is just for typechecking
(to be used in the bindings generator), so like other accessors of
InstanceType or typecheck methods, it is not exposed in the public API.

* InstancePre: rather than keep a ComponentType, just keep the resource type table

construct InstanceType right from the contents of InstancePre instead of
using the intermediate ComponentType. The net is that InstancePre is
just one word larger & one arc clone more expensive than before.

Author: pchickey

crates/wasmtime/src/runtime/component/instance.rs

@@ -10,7 +10,7 @@ use crate::prelude::*;
 use crate::runtime::vm::component::{ComponentInstance, OwnedComponentInstance};
 use crate::runtime::vm::{CompiledModuleId, VMFuncRef};
 use crate::store::{StoreOpaque, Stored};
-use crate::{AsContextMut, Engine, Module, StoreContextMut};
+use crate::{AsContext, AsContextMut, Engine, Module, StoreContextMut};
 use alloc::sync::Arc;
 use core::marker;
 use core::ptr::NonNull;
@@ -362,6 +362,20 @@ impl Instance {
             index,
         ))
     }
+
+    #[doc(hidden)]
+    pub fn instance_pre<T>(&self, store: &impl AsContext<Data = T>) -> InstancePre<T> {
+        // This indexing operation asserts the Store owns the Instance.
+        // Therefore, the InstancePre<T> must match the Store<T>.
+        let data = store.as_context().0[self.0].as_ref().unwrap();
+        unsafe {
+            InstancePre::new_unchecked(
+                data.component.clone(),
+                data.imports.clone(),
+                data.instance().resource_types().clone(),
+            )
+        }
+    }
 }
 
 /// Trait used to lookup the export of a component instance.
@@ -815,6 +829,7 @@ impl<'a> Instantiator<'a> {
 pub struct InstancePre<T> {
     component: Component,
     imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
+    resource_types: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
     _marker: marker::PhantomData<fn() -> T>,
 }
 
@@ -824,6 +839,7 @@ impl<T> Clone for InstancePre<T> {
         Self {
             component: self.component.clone(),
             imports: self.imports.clone(),
+            resource_types: self.resource_types.clone(),
             _marker: self._marker,
         }
     }
@@ -838,11 +854,13 @@ impl<T> InstancePre<T> {
     /// satisfy the imports of the `component` provided.
     pub(crate) unsafe fn new_unchecked(
         component: Component,
-        imports: PrimaryMap<RuntimeImportIndex, RuntimeImport>,
+        imports: Arc<PrimaryMap<RuntimeImportIndex, RuntimeImport>>,
+        resource_types: Arc<PrimaryMap<ResourceIndex, ResourceType>>,
     ) -> InstancePre<T> {
         InstancePre {
             component,
-            imports: Arc::new(imports),
+            imports,
+            resource_types,
             _marker: marker::PhantomData,
         }
     }
@@ -852,6 +870,17 @@ impl<T> InstancePre<T> {
         &self.component
     }
 
+    #[doc(hidden)]
+    /// Returns the type at which the underlying component will be
+    /// instantiated. This contains the instantiated type information which
+    /// was determined by the Linker.
+    pub fn instance_type(&self) -> InstanceType<'_> {
+        InstanceType {
+            types: &self.component.types(),
+            resources: &self.resource_types,
+        }
+    }
+
     /// Returns the underlying engine.
     pub fn engine(&self) -> &Engine {
         self.component.engine()

crates/wasmtime/src/runtime/component/linker.rs

@@ -210,7 +210,12 @@ impl<T> Linker<T> {
     /// `component` imports or if a name defined doesn't match the type of the
     /// item imported by the `component` provided.
     pub fn instantiate_pre(&self, component: &Component) -> Result<InstancePre<T>> {
-        self.typecheck(&component)?;
+        let cx = self.typecheck(&component)?;
+
+        // A successful typecheck resolves all of the imported resources used by
+        // this InstancePre. We keep a clone of this table in the InstancePre
+        // so that we can construct an InstanceType for typechecking.
+        let imported_resources = cx.imported_resources.clone();
 
         // Now that all imports are known to be defined and satisfied by this
         // linker a list of "flat" import items (aka no instances) is created
@@ -247,7 +252,9 @@ impl<T> Linker<T> {
             let i = imports.push(import);
             assert_eq!(i, idx);
         }
-        Ok(unsafe { InstancePre::new_unchecked(component.clone(), imports) })
+        Ok(unsafe {
+            InstancePre::new_unchecked(component.clone(), Arc::new(imports), imported_resources)
+        })
     }
 
     /// Instantiates the [`Component`] provided into the `store` specified.

crates/wasmtime/src/runtime/component/types.rs

@@ -816,6 +816,14 @@ impl Component {
             )
         })
     }
+
+    #[doc(hidden)]
+    pub fn instance_type(&self) -> InstanceType<'_> {
+        InstanceType {
+            types: &self.0.types,
+            resources: &self.0.resources,
+        }
+    }
 }
 
 /// Component instance type