tweak rules to determine whether recursive reentrance is possible

This accounts for components which instantiate imported modules and/or
components.

Author: dicej

crates/environ/src/component/translate.rs

@@ -80,12 +80,13 @@ pub struct Translator<'a, 'data> {
     /// The top-level import name for Wasmtime's unsafe intrinsics, if any.
     unsafe_intrinsics_import: Option<&'a str>,
 
-    /// Whether this component contains any modules outside of leaf components.
+    /// Whether this component contains any module instantiations outside of
+    /// leaf components.
     ///
     /// We'll use this when generating fused adapters; if it's false, then we
     /// know that no guest-to-guest call can reenter a runtime instance
     /// recursively.
-    has_nonleaf_modules: bool,
+    has_nonleaf_module_instantiations: bool,
 }
 
 /// Representation of the syntactic scope of a component meaning where it is
@@ -179,12 +180,13 @@ struct Translation<'data> {
     /// is set to `None`.
     types: Option<Types>,
 
-    /// Whether we've encountered a module while parsing this component
-    /// (but ignoring modules found in subcomponents).
-    saw_module: bool,
+    /// Whether we've encountered a module instantiation while parsing this
+    /// component (disregarding instantiations in subcomponents).
+    saw_module_instantiation: bool,
 
-    /// Whether we've encountered a subcomponent while parsing this component.
-    saw_component: bool,
+    /// Whether we've encountered a component instantation while parsing this
+    /// component (disregarding instantiations in subcomponents).
+    saw_component_instantiation: bool,
 }
 
 // NB: the type information contained in `LocalInitializer` should always point
@@ -469,7 +471,7 @@ impl<'a, 'data> Translator<'a, 'data> {
             static_modules: Default::default(),
             scope_vec,
             unsafe_intrinsics_import: None,
-            has_nonleaf_modules: false,
+            has_nonleaf_module_instantiations: false,
         }
     }
 
@@ -710,7 +712,8 @@ impl<'a, 'data> Translator<'a, 'data> {
                 assert!(self.result.types.is_none());
                 self.result.types = Some(self.validator.end(offset)?);
 
-                self.has_nonleaf_modules |= self.result.saw_module && self.result.saw_component;
+                self.has_nonleaf_module_instantiations |=
+                    self.result.saw_module_instantiation && self.result.saw_component_instantiation;
 
                 // Exit the current lexical scope. If there is no parent (no
                 // frame currently on the stack) then translation is finished.
@@ -1211,7 +1214,6 @@ impl<'a, 'data> Translator<'a, 'data> {
                 parser,
                 unchecked_range,
             } => {
-                self.result.saw_module = true;
                 let index = self.validator.types(0).unwrap().module_count();
                 self.validator.module_section(&unchecked_range)?;
                 let static_module_index = self.static_modules.next_key();
@@ -1257,7 +1259,6 @@ impl<'a, 'data> Translator<'a, 'data> {
                 parser,
                 unchecked_range,
             } => {
-                self.result.saw_component = true;
                 self.validator.component_section(&unchecked_range)?;
                 self.lexical_scopes.push(LexicalScope {
                     parser: mem::replace(&mut self.parser, parser),
@@ -1271,6 +1272,7 @@ impl<'a, 'data> Translator<'a, 'data> {
             // largely just records the arguments given from wasmparser into a
             // `HashMap` for processing later during inlining.
             Payload::InstanceSection(s) => {
+                self.result.saw_module_instantiation = true;
                 self.validator.instance_section(&s)?;
                 for instance in s {
                     let init = match instance? {
@@ -1286,6 +1288,7 @@ impl<'a, 'data> Translator<'a, 'data> {
                 }
             }
             Payload::ComponentInstanceSection(s) => {
+                self.result.saw_component_instantiation = true;
                 let mut index = self.validator.types(0).unwrap().component_instance_count();
                 self.validator.component_instance_section(&s)?;
                 for instance in s {

crates/environ/src/component/translate/adapt.rs

@@ -208,7 +208,7 @@ impl<'data> Translator<'_, 'data> {
             let mut module = fact::Module::new(
                 self.types.types(),
                 self.tunables.debug_adapter_modules,
-                self.has_nonleaf_modules,
+                self.has_nonleaf_module_instantiations,
             );
             let mut names = Vec::with_capacity(adapter_module.adapters.len());
             for adapter in adapter_module.adapters.iter() {