refactor(compiler): remove duplicate named type index (#613)

Author: zharinov

crates/plotnik-lib/src/compiler/analyze/result.rs

@@ -379,7 +379,6 @@ impl PublicResultGroup {
 pub(crate) struct ResultModel {
     reachable_defs: DefinitionReachability,
     type_layout: ResultTypeLayout,
-    named_types: BTreeMap<TypeId, Symbol>,
     type_name_bindings: Vec<TypeNameBinding>,
     entry_point_items: Vec<ResultItem>,
     capture_layout: CaptureLayout,
@@ -421,10 +420,9 @@ impl ResultModel {
             &collected_types.builtins,
             collected_types.value_types,
         );
-        let named_types: BTreeMap<TypeId, Symbol> = types.iter_named_types().collect();
-        let mut type_name_bindings = named_types
-            .iter()
-            .map(|(&type_id, &name)| TypeNameBinding { name, type_id })
+        let mut type_name_bindings = types
+            .iter_named_types()
+            .map(|(type_id, name)| TypeNameBinding { name, type_id })
             .collect::<Vec<_>>();
         for def_id in reachable_defs.iter() {
             let Some(body) = types.expect_def_output(def_id).value() else {
@@ -437,8 +435,8 @@ impl ResultModel {
         }
         type_name_bindings.sort_by_key(|binding| (binding.type_id, binding.name));
         type_name_bindings.dedup();
-        let entry_point_items = ItemCollector::new(types, definitions, &named_types)
-            .collect(artifacts.iter_entry_point_outputs());
+        let entry_point_items =
+            ItemCollector::new(types, definitions).collect(artifacts.iter_entry_point_outputs());
         let mut public_result_groups = BTreeMap::new();
         for item in entry_point_items
             .iter()
@@ -451,7 +449,7 @@ impl ResultModel {
             );
             assert!(previous.is_none(), "public result item names are unique");
         }
-        for (&type_id, &name) in &named_types {
+        for (type_id, name) in types.iter_named_types() {
             let Some(group) = public_result_groups.get_mut(&name) else {
                 continue;
             };
@@ -466,7 +464,6 @@ impl ResultModel {
         Ok(Self {
             reachable_defs,
             type_layout,
-            named_types,
             type_name_bindings,
             entry_point_items,
             capture_layout,
@@ -509,10 +506,6 @@ impl ResultModel {
         );
         group
     }
-
-    pub(crate) fn type_name_of(&self, type_id: TypeId) -> Option<Symbol> {
-        self.named_types.get(&type_id).copied()
-    }
 }
 
 impl<'a> ResultSchema<'a> {
@@ -534,10 +527,6 @@ impl<'a> ResultSchema<'a> {
         &self.model.type_layout
     }
 
-    pub(crate) fn type_name_of(&self, type_id: TypeId) -> Option<Symbol> {
-        self.model.type_name_of(type_id)
-    }
-
     pub(crate) fn iter_type_name_bindings(&self) -> impl Iterator<Item = TypeNameBinding> + '_ {
         self.model.type_name_bindings.iter().copied()
     }
@@ -572,22 +561,16 @@ impl<'a> ResultSchema<'a> {
 struct ItemCollector<'a> {
     types: &'a TypeAnalysis,
     definitions: &'a DefinitionGraph,
-    named_types: &'a BTreeMap<TypeId, Symbol>,
     declared_names: HashSet<Symbol>,
     walked_types: HashSet<TypeId>,
     items: Vec<ResultItem>,
 }
 
 impl<'a> ItemCollector<'a> {
-    fn new(
-        types: &'a TypeAnalysis,
-        definitions: &'a DefinitionGraph,
-        named_types: &'a BTreeMap<TypeId, Symbol>,
-    ) -> Self {
+    fn new(types: &'a TypeAnalysis, definitions: &'a DefinitionGraph) -> Self {
         Self {
             types,
             definitions,
-            named_types,
             declared_names: HashSet::new(),
             walked_types: HashSet::new(),
             items: Vec::new(),
@@ -655,14 +638,14 @@ impl<'a> ItemCollector<'a> {
     fn collect_position(&mut self, ty: TypeId) {
         match self.types.expect_type_shape(ty) {
             TypeShape::Record(_) | TypeShape::Variant(_) => {
-                let name = *self
-                    .named_types
-                    .get(&ty)
+                let name = self
+                    .types
+                    .type_name_of(ty)
                     .expect("naming pass names every non-payload composite");
                 self.add_item(name, ty);
             }
             TypeShape::List { .. } | TypeShape::Option(_) => {
-                let Some(&name) = self.named_types.get(&ty) else {
+                let Some(name) = self.types.type_name_of(ty) else {
                     self.walk(ty);
                     return;
                 };

crates/plotnik-lib/src/compiler/analyze/types/type_analysis.rs

@@ -556,6 +556,10 @@ impl TypeAnalysis {
             })
     }
 
+    pub(crate) fn type_name_of(&self, type_id: TypeId) -> Option<Symbol> {
+        self.named_types.get(&type_id).copied()
+    }
+
     /// Iterate generated and explicitly named structural bodies in `TypeId`
     /// order. Definition declarations are exposed separately through their
     /// `DefId` and output body.

crates/plotnik-lib/src/compiler/emit/decode.rs

@@ -210,6 +210,7 @@ impl DecodePlanBuilder<'_, '_> {
             TypeShape::Record(_) | TypeShape::Variant(_) => DecodeValue::Nested {
                 item: self
                     .schema
+                    .types
                     .type_name_of(ty)
                     .expect("naming pass names every non-payload composite"),
                 source_type: ty,
@@ -244,7 +245,7 @@ impl DecodePlanBuilder<'_, '_> {
         if !seen.insert(ty) {
             return false;
         }
-        if let Some(name) = self.schema.type_name_of(ty)
+        if let Some(name) = self.schema.types.type_name_of(ty)
             && self.item_enters_depth(name)
         {
             return true;

crates/plotnik-lib/src/compiler/emit/targets/rust/types.rs

@@ -244,6 +244,7 @@ impl<'m, 'a> Emitter<'m, 'a> {
             TypeShape::Record(_) | TypeShape::Variant(_) => {
                 let name = self
                     .schema
+                    .types
                     .type_name_of(ty)
                     .expect("naming pass names every composite outside enum-variant payloads");
                 self.named_type(name, ty)

crates/plotnik-lib/src/compiler/emit/targets/typescript/types.rs

@@ -232,7 +232,7 @@ impl<'a> SchemaEmitter<'a> {
 
     fn render_ty(&self, ty: TypeId) -> Sink<SemanticTag> {
         if !ty.is_builtin()
-            && let Some(symbol) = self.schema.type_name_of(ty)
+            && let Some(symbol) = self.schema.types.type_name_of(ty)
             && self.items_by_name.contains_key(&symbol)
         {
             let mut out = Sink::new();

crates/plotnik-lib/src/compiler/lower/spans.rs

@@ -358,7 +358,7 @@ fn custom_capture_type_binding(
         .final_type;
 
     loop {
-        if input.result.type_name_of(type_id) == Some(written_name) {
+        if input.analysis.type_analysis.type_name_of(type_id) == Some(written_name) {
             return Some(SpanBindingIR::Type(type_id));
         }
         match input.analysis.type_analysis.type_shape(type_id) {