add union types to schema

src/adapter/edges.rs

@@ -325,6 +325,35 @@ pub(super) fn resolve_enum_edge<'a, V: AsVertex<Vertex<'a>> + 'a>(
     }
 }
 
+pub(super) fn resolve_union_edge<'a, V: AsVertex<Vertex<'a>> + 'a>(
+    contexts: ContextIterator<'a, V>,
+    edge_name: &str,
+    current_crate: &'a IndexedCrate<'a>,
+    previous_crate: Option<&'a IndexedCrate<'a>>,
+) -> ContextOutcomeIterator<'a, V, VertexIterator<'a, Vertex<'a>>> {
+    match edge_name {
+        "field" => resolve_neighbors_with(contexts, move |vertex| {
+            let origin = vertex.origin;
+            let union_item = vertex.as_union().expect("vertex was not an Union");
+
+            let item_index = match origin {
+                Origin::CurrentCrate => &current_crate.inner.index,
+                Origin::PreviousCrate => {
+                    &previous_crate
+                        .expect("no previous crate provided")
+                        .inner
+                        .index
+                }
+            };
+
+            Box::new(union_item.fields.iter().map(move |field_id| {
+                origin.make_item_vertex(item_index.get(field_id).expect("missing item"))
+            }))
+        }),
+        _ => unreachable!("resolve_union_edge {edge_name}"),
+    }
+}
+
 pub(super) fn resolve_struct_field_edge<'a, V: AsVertex<Vertex<'a>> + 'a>(
     contexts: ContextIterator<'a, V>,
     edge_name: &str,

src/adapter/mod.rs

@@ -92,8 +92,8 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                 "Crate" => properties::resolve_crate_property(contexts, property_name),
                 "Item" => properties::resolve_item_property(contexts, property_name),
                 "ImplOwner" | "Struct" | "StructField" | "Enum" | "Variant" | "PlainVariant"
-                | "TupleVariant" | "StructVariant" | "Trait" | "Function" | "Method" | "Impl"
-                | "GlobalValue" | "Constant" | "Static" | "AssociatedType"
+                | "TupleVariant" | "StructVariant" | "Union" | "Trait" | "Function" | "Method"
+                | "Impl" | "GlobalValue" | "Constant" | "Static" | "AssociatedType"
                 | "AssociatedConstant" | "Module"
                     if matches!(
                         property_name.as_ref(),
@@ -113,6 +113,7 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                 "Module" => properties::resolve_module_property(contexts, property_name),
                 "Struct" => properties::resolve_struct_property(contexts, property_name),
                 "Enum" => properties::resolve_enum_property(contexts, property_name),
+                "Union" => properties::resolve_union_property(contexts, property_name),
                 "Span" => properties::resolve_span_property(contexts, property_name),
                 "Path" => properties::resolve_path_property(contexts, property_name),
                 "ImportablePath" => {
@@ -165,7 +166,7 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
         match type_name.as_ref() {
             "CrateDiff" => edges::resolve_crate_diff_edge(contexts, edge_name),
             "Crate" => edges::resolve_crate_edge(self, contexts, edge_name, resolve_info),
-            "Importable" | "ImplOwner" | "Struct" | "Enum" | "Trait" | "Function"
+            "Importable" | "ImplOwner" | "Struct" | "Enum" | "Union" | "Trait" | "Function"
             | "GlobalValue" | "Constant" | "Static" | "Module"
                 if matches!(edge_name.as_ref(), "importable_path" | "canonical_path") =>
             {
@@ -177,14 +178,14 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                 )
             }
             "Item" | "ImplOwner" | "Struct" | "StructField" | "Enum" | "Variant"
-            | "PlainVariant" | "TupleVariant" | "StructVariant" | "Trait" | "Function"
-            | "Method" | "Impl" | "GlobalValue" | "Constant" | "Static" | "AssociatedType"
-            | "AssociatedConstant" | "Module"
+            | "PlainVariant" | "TupleVariant" | "Union" | "StructVariant" | "Trait"
+            | "Function" | "Method" | "Impl" | "GlobalValue" | "Constant" | "Static"
+            | "AssociatedType" | "AssociatedConstant" | "Module"
                 if matches!(edge_name.as_ref(), "span" | "attribute") =>
             {
                 edges::resolve_item_edge(contexts, edge_name)
             }
-            "ImplOwner" | "Struct" | "Enum"
+            "ImplOwner" | "Struct" | "Enum" | "Union"
                 if matches!(edge_name.as_ref(), "impl" | "inherent_impl") =>
             {
                 edges::resolve_impl_owner_edge(self, contexts, edge_name, resolve_info)
@@ -220,6 +221,12 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                 self.current_crate,
                 self.previous_crate,
             ),
+            "Union" => edges::resolve_union_edge(
+                contexts,
+                edge_name,
+                self.current_crate,
+                self.previous_crate,
+            ),
             "StructField" => edges::resolve_struct_field_edge(contexts, edge_name),
             "Impl" => edges::resolve_impl_edge(self, contexts, edge_name, resolve_info),
             "Trait" => edges::resolve_trait_edge(
@@ -254,7 +261,7 @@ impl<'a> Adapter<'a> for RustdocAdapter<'a> {
                             actual_type_name,
                             "PlainVariant" | "TupleVariant" | "StructVariant"
                         ),
-                        "ImplOwner" => matches!(actual_type_name, "Struct" | "Enum"),
+                        "ImplOwner" => matches!(actual_type_name, "Struct" | "Enum" | "Union"),
                         "GlobalValue" => matches!(actual_type_name, "Constant" | "Static",),
                         _ => {
                             // The remaining types are final (don't have any subtypes)
@@ -277,6 +284,7 @@ pub(crate) fn supported_item_kind(item: &Item) -> bool {
             | rustdoc_types::ItemEnum::StructField(..)
             | rustdoc_types::ItemEnum::Enum(..)
             | rustdoc_types::ItemEnum::Variant(..)
+            | rustdoc_types::ItemEnum::Union(..)
             | rustdoc_types::ItemEnum::Function(..)
             | rustdoc_types::ItemEnum::Impl(..)
             | rustdoc_types::ItemEnum::Trait(..)

src/adapter/optimizations/impl_lookup.rs

@@ -189,13 +189,14 @@ fn resolve_owner_impl_slow_path<'a>(
     };
 
     // Get the IDs of all the impl blocks.
-    // Relies on the fact that only structs and enums can have impls,
-    // so we know that the vertex must represent either a struct or an enum.
+    // Relies on the fact that only structs, enums, and unions can have impls,
+    // so we know that the vertex must represent either a struct, enum, or union.
     let impl_ids = vertex
         .as_struct()
         .map(|s| &s.impls)
         .or_else(|| vertex.as_enum().map(|e| &e.impls))
-        .expect("vertex was neither a struct nor an enum");
+        .or_else(|| vertex.as_union().map(|u| &u.impls))
+        .expect("vertex was neither a struct, enum, or union");
 
     Box::new(impl_ids.iter().filter_map(move |item_id| {
         let next_item = item_index.get(item_id);

src/adapter/properties.rs

@@ -170,6 +170,18 @@ pub(super) fn resolve_enum_property<'a, V: AsVertex<Vertex<'a>> + 'a>(
     }
 }
 
+pub(super) fn resolve_union_property<'a, V: AsVertex<Vertex<'a>> + 'a>(
+    contexts: ContextIterator<'a, V>,
+    property_name: &str,
+) -> ContextOutcomeIterator<'a, V, FieldValue> {
+    match property_name {
+        "fields_stripped" => {
+            resolve_property_with(contexts, field_property!(as_union, fields_stripped))
+        }
+        _ => unreachable!("Union property {property_name}"),
+    }
+}
+
 pub(super) fn resolve_path_property<'a, V: AsVertex<Vertex<'a>> + 'a>(
     contexts: ContextIterator<'a, V>,
     property_name: &str,