Don't assume item is the top level item from the node

Signed-off-by: Ryan Levick <ryan.levick@fermyon.com>

Author: rylev

crates/wac-graph/src/graph.rs

@@ -1261,8 +1261,10 @@ impl CompositionGraph {
     }
 
     /// Yields an iterator over the resolved imports (both implicit and explicit) of the graph.
-    pub fn imports(&self) -> impl Iterator<Item = (&str, NodeId)> {
-        let mut imports = HashMap::new();
+    ///
+    /// The iterator returns the name, the `ItemKind`, and an optional node id for explicit imports.
+    pub fn imports(&self) -> impl Iterator<Item = (&str, ItemKind, Option<NodeId>)> {
+        let mut imports = Vec::new();
         for index in self.graph.node_indices() {
             let node = &self.graph[index];
             if !matches!(node.kind, NodeKind::Instantiation(_)) {
@@ -1279,15 +1281,15 @@ impl CompositionGraph {
                 .filter(|(i, _)| !node.is_arg_satisfied(*i));
 
             // Go through the unsatisfied arguments and import them
-            for (_, (name, _)) in unsatisfied_args {
-                imports.insert(name.as_str(), NodeId(index));
+            for (_, (name, item_kind)) in unsatisfied_args {
+                imports.push((name.as_str(), *item_kind, None));
             }
         }
 
         for n in self.node_ids() {
             let node = &self.graph[n.0];
             if let NodeKind::Import(name) = &node.kind {
-                imports.insert(name.as_str(), n);
+                imports.push((name.as_str(), node.item_kind, Some(n)));
             }
         }
         imports.into_iter()

crates/wac-parser/src/resolution.rs

@@ -635,7 +635,7 @@ pub enum Error {
         world: String,
         /// The span where the error occurred.
         #[label(primary, "mismatched type for {kind} `{name}`")]
-        span: SourceSpan,
+        span: Option<SourceSpan>,
         /// The source of the error.
         #[source]
         source: anyhow::Error,
@@ -2717,28 +2717,28 @@ impl<'a> AstResolver<'a> {
 
         // The output is allowed to import a subset of the world's imports
         checker.invert();
-        for (name, import) in state.graph.imports() {
+        for (name, item_kind, import_node) in state.graph.imports() {
             let expected = world
                 .imports
                 .get(name)
                 .ok_or_else(|| Error::ImportNotInTarget {
                     name: name.to_owned(),
                     world: path.string.to_owned(),
-                    span: state.import_spans.get(&import).copied(),
+                    span: import_node.map(|n| state.import_spans[&n]),
                 })?;
 
             checker
                 .is_subtype(
                     expected.promote(),
                     state.graph.types(),
-                    state.graph[import].item_kind(),
+                    item_kind,
                     state.graph.types(),
                 )
                 .map_err(|e| Error::TargetMismatch {
                     kind: ExternKind::Import,
                     name: name.to_owned(),
                     world: path.string.to_owned(),
-                    span: state.import_spans[&import],
+                    span: import_node.map(|n| state.import_spans[&n]),
                     source: e,
                 })?;
         }
@@ -2769,7 +2769,7 @@ impl<'a> AstResolver<'a> {
                     kind: ExternKind::Export,
                     name: name.clone(),
                     world: path.string.to_owned(),
-                    span: state.export_spans[&export],
+                    span: state.export_spans.get(&export).copied(),
                     source: e,
                 })?;
         }