generic duplication key

Author: Natoandro

src/metagen/src/client_rs/mod.rs

@@ -229,11 +229,11 @@ impl RsClientManifest {
     ) -> anyhow::Result<()> {
         render_static(dest, opts.hostcall)?;
 
-        self.types.render_full(dest)?;
-
         let methods = self.node_metas.render_all_buffered()?;
         with_metas_namespace(dest, methods)?;
 
+        self.types.render_full(dest)?;
+
         self.selections.render_all(dest)?;
 
         self.render_query_graph(dest)?;
@@ -311,7 +311,7 @@ pub fn query_graph() -> QueryGraph {{
             let args_row = match &arg_ty {
                 Some(arg_ty) => format!(
                     "
-            args: impl Into<NodeArgs<{arg_ty}>>"
+        args: impl Into<NodeArgs<{arg_ty}>>"
                 ),
                 None => "".into(),
             };

src/metagen/src/client_rs/selections.rs

@@ -211,7 +211,7 @@ pub fn manifest_page(
                     let selection = selection_for_field(variant);
                     variants.push(UnionProp {
                         name: struct_prop_name,
-                        variant_ty: variant.name().to_string(), // FIXME normalized??
+                        variant_ty: variant.name().to_string(),
                         select_ty: selection,
                     });
                 }

src/typegraph/graph/src/conv/dedup.rs

@@ -1,44 +1,128 @@
 // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0.
 // SPDX-License-Identifier: MPL-2.0
 
-use tg_schema::InjectionNode;
+use crate::{injection::InjectionNode, interlude::*, Type, TypeNodeExt as _, Wrap};
 
-use crate::{interlude::*, Type, TypeNodeExt as _, Wrap as _};
+use super::{key::TypeKeyEx, ConversionMap, MapItem, PathSegment, RelativePath, TypeKey};
 
-use super::{ConversionMap, MapItem, RelativePath, TypeKey};
+// TODO rename to `DuplicationKey`
+pub trait DupKey: std::hash::Hash + Eq + Clone {
+    fn is_default(&self) -> bool;
+}
+
+pub trait DuplicationKeyGenerator: Clone {
+    type Key: DupKey;
+
+    fn gen_from_rpath(&self, rpath: &RelativePath) -> Self::Key;
+    fn gen_from_type(&self, ty: &Type) -> Self::Key;
+
+    fn apply_path_segment(&self, key: &Self::Key, path_seg: &PathSegment) -> Self::Key;
+
+    fn find_type_in_rpath(
+        &self,
+        ty: &Type,
+        rpath: &RelativePath,
+        schema: &tg_schema::Typegraph,
+    ) -> bool {
+        use RelativePath as RP;
+        match rpath {
+            RP::Function(_) => false,
+            RP::NsObject(_) => false,
+            RP::Input(p) => {
+                let owner = p.owner.upgrade().expect("no strong pointer for type");
+                let input_type = match &schema.types[owner.base.key.0 as usize] {
+                    tg_schema::TypeNode::Function { data, .. } => data.input,
+                    _ => unreachable!("expected a function node"),
+                };
+                let xkey = TypeKeyEx(ty.idx(), self.gen_from_type(ty));
+                let mut cursor = TypeKeyEx(
+                    input_type,
+                    self.gen_from_rpath(&RelativePath::input(Arc::downgrade(&owner), vec![])),
+                );
+                // let mut cursor = TypeKeyEx(input_type, DuplicationKey { injection });
+                for seg in &p.path {
+                    let next_dkey = self.apply_path_segment(&cursor.1, seg);
+                    // FIXME why unwrap?
+                    let idx = seg.apply_on_schema_node(&schema.types, cursor.0).unwrap();
+                    let next = TypeKeyEx(idx, next_dkey);
+                    if next == xkey {
+                        return true;
+                    }
+                    cursor = next;
+                }
+
+                false
+            }
+
+            RP::Output(p) => {
+                let owner = p.owner.upgrade().expect("no strong pointer for type");
+                let out_ty = match &schema.types[owner.base.key.0 as usize] {
+                    tg_schema::TypeNode::Function { data, .. } => data.output,
+                    _ => unreachable!("expected a function node"),
+                };
+
+                let xkey = TypeKeyEx(ty.idx(), self.gen_from_type(ty));
+
+                let mut cursor = TypeKeyEx(
+                    out_ty,
+                    self.gen_from_rpath(&RelativePath::output(Arc::downgrade(&owner), vec![])),
+                );
+                for seg in &p.path {
+                    let next_dkey = self.apply_path_segment(&cursor.1, seg);
+                    let idx = seg.apply_on_schema_node(&schema.types, cursor.0).unwrap();
+                    let next = TypeKeyEx(idx, next_dkey);
+                    if next == xkey {
+                        return true;
+                    }
+                    cursor = next;
+                }
 
-#[derive(Default, Debug, PartialEq, Eq, Hash)]
-pub struct DuplicationKey {
-    pub injection: Option<InjectionNode>,
+                false
+            }
+        }
+    }
 }
 
-impl DuplicationKey {
-    fn new(ty: &Type) -> Self {
-        Self {
-            injection: ty.injection().cloned(),
+#[derive(Default, Clone, Debug, PartialEq, Eq, Hash)]
+pub struct DefaultDuplicationKey {
+    pub injection: Option<Arc<InjectionNode>>,
+}
+
+#[derive(Clone, Debug)]
+pub struct DefaultDuplicationKeyGenerator;
+
+impl DuplicationKeyGenerator for DefaultDuplicationKeyGenerator {
+    type Key = DefaultDuplicationKey;
+
+    fn gen_from_rpath(&self, rpath: &RelativePath) -> Self::Key {
+        Self::Key {
+            injection: rpath.get_injection(),
         }
     }
 
-    pub fn from_rpath(schema: &tg_schema::Typegraph, rpath: &RelativePath) -> Self {
-        Self {
-            injection: rpath.get_injection(schema),
+    fn gen_from_type(&self, ty: &Type) -> Self::Key {
+        Self::Key {
+            injection: ty.injection(),
         }
     }
 
-    pub fn is_empty(&self) -> bool {
+    fn apply_path_segment(&self, key: &Self::Key, path_seg: &PathSegment) -> Self::Key {
+        let inj = key
+            .injection
+            .as_ref()
+            .and_then(|inj| path_seg.apply_on_injection(inj));
+        Self::Key { injection: inj }
+    }
+}
+impl DupKey for DefaultDuplicationKey {
+    fn is_default(&self) -> bool {
         self.injection
             .as_ref()
             .map(|inj| inj.is_empty())
             .unwrap_or(true)
     }
 }
 
-impl From<&Type> for DuplicationKey {
-    fn from(ty: &Type) -> Self {
-        Self::new(ty)
-    }
-}
-
 pub enum Deduplication {
     /// a previously registered type was found
     Reuse(Type),
@@ -55,12 +139,15 @@ impl Deduplication {
     }
 }
 
-impl ConversionMap {
-    pub fn deduplicate(&self, type_idx: u32, dkey: &DuplicationKey) -> Result<Deduplication> {
+impl<DKG: DuplicationKeyGenerator> ConversionMap<DKG> {
+    pub fn deduplicate(&self, type_idx: u32, dkey: &DKG::Key) -> Result<Deduplication>
+    where
+        DKG: DuplicationKeyGenerator,
+    {
         match self.direct.get(type_idx as usize) {
             Some(MapItem::Unset) => Ok(Deduplication::register(
                 type_idx,
-                match dkey.is_empty() {
+                match dkey.is_default() {
                     true => 0,
                     // Duplication key will always be empty for functions and namespaces;
                     // hence, this will always be valid.
@@ -72,7 +159,7 @@ impl ConversionMap {
             }
             Some(MapItem::Function(fn_ty)) => Ok(Deduplication::reuse(fn_ty.wrap())),
             Some(MapItem::Value(value_type)) => {
-                if dkey.is_empty() {
+                if dkey.is_default() {
                     if let Some(item) = value_type.default.as_ref() {
                         Ok(Deduplication::reuse(item.ty.clone()))
                     } else {

src/typegraph/graph/src/conv/key.rs

@@ -1,9 +1,7 @@
 // Copyright Metatype OÜ, licensed under the Mozilla Public License Version 2.0.
 // SPDX-License-Identifier: MPL-2.0
 
-use crate::{Type, TypeNodeExt as _};
-
-use super::dedup::DuplicationKey;
+use super::dedup::DupKey;
 
 #[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
 pub struct TypeKey(pub u32, pub u32); // Type idx and an variant id (duplicate id)
@@ -15,10 +13,4 @@ impl std::fmt::Debug for TypeKey {
 }
 
 #[derive(Debug, PartialEq)]
-pub struct TypeKeyEx(pub u32, pub DuplicationKey);
-
-impl From<&Type> for TypeKeyEx {
-    fn from(ty: &Type) -> Self {
-        Self(ty.idx(), From::from(ty))
-    }
-}
+pub struct TypeKeyEx<K: DupKey>(pub u32, pub K);

src/typegraph/graph/src/conv/map.rs

@@ -8,7 +8,7 @@ use crate::path::ValueTypePath;
 use crate::{Arc, FunctionType, ObjectType, Type, TypeNodeExt as _};
 use std::collections::HashMap;
 
-use super::dedup::DuplicationKey;
+use super::dedup::{DupKey, DuplicationKeyGenerator};
 use super::{RelativePath, TypeKey};
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
@@ -24,13 +24,13 @@ pub struct MapValueItem {
 }
 
 #[derive(Debug)]
-pub struct ValueType {
+pub struct ValueType<K: DupKey> {
     pub default: Option<MapValueItem>,
     // duplication
-    pub variants: IndexMap<DuplicationKey, MapValueItem>,
+    pub variants: IndexMap<K, MapValueItem>,
 }
 
-impl ValueType {
+impl<K: DupKey> ValueType<K> {
     pub fn get(&self, variant_idx: u32) -> Option<&MapValueItem> {
         let variant_idx = variant_idx as usize;
         if variant_idx == 0 {
@@ -59,15 +59,15 @@ impl ValueType {
 }
 
 #[derive(Debug)]
-pub enum MapItem {
+pub enum MapItem<K: DupKey> {
     Unset,
     Namespace(Arc<ObjectType>, Vec<Arc<str>>),
     Function(Arc<FunctionType>),
-    Value(ValueType),
+    Value(ValueType<K>),
 }
 
-impl MapItem {
-    pub fn as_value(&self) -> Option<&ValueType> {
+impl<K: DupKey> MapItem<K> {
+    pub fn as_value(&self) -> Option<&ValueType<K>> {
         match self {
             Self::Value(v) => Some(v),
             _ => None,
@@ -76,17 +76,19 @@ impl MapItem {
 }
 
 #[derive(Debug)]
-pub struct ConversionMap {
-    pub direct: Vec<MapItem>,
+pub struct ConversionMap<G: DuplicationKeyGenerator> {
+    dup_key_gen: G,
+    pub direct: Vec<MapItem<G::Key>>,
     pub reverse: HashMap<RelativePath, TypeKey>,
 }
 
-impl ConversionMap {
-    pub fn new(schema: &tg_schema::Typegraph) -> Self {
+impl<G: DuplicationKeyGenerator> ConversionMap<G> {
+    pub fn new(schema: &tg_schema::Typegraph, dup_key_gen: &G) -> Self {
         let type_count = schema.types.len();
         let mut direct = Vec::with_capacity(type_count);
         direct.resize_with(type_count, || MapItem::Unset);
         Self {
+            dup_key_gen: dup_key_gen.clone(),
             direct,
             reverse: Default::default(),
         }
@@ -120,7 +122,7 @@ impl ConversionMap {
     }
 }
 
-impl ConversionMap {
+impl<G: DuplicationKeyGenerator> ConversionMap<G> {
     pub fn register(&mut self, rpath: RelativePath, node: Type) -> Result<()> {
         let key = node.key();
         let item = std::mem::replace(&mut self.direct[key.0 as usize], MapItem::Unset);
@@ -131,8 +133,8 @@ impl ConversionMap {
                     MapItem::Namespace(node.assert_object()?.clone(), path.clone())
                 }
                 RelativePath::Input(_) => {
-                    let dkey = DuplicationKey::from(&node);
-                    if dkey.is_empty() || !node.is_composite() {
+                    let dkey = self.dup_key_gen.gen_from_type(&node);
+                    if dkey.is_default() || !node.is_composite() {
                         MapItem::Value(ValueType {
                             default: Some(MapValueItem {
                                 ty: node.clone(),
@@ -182,9 +184,9 @@ impl ConversionMap {
                     .clone()
                     .try_into()
                     .map_err(|e| eyre!("relative path is not a value type: {:?}", e))?;
-                let dkey = DuplicationKey::from(&node);
+                let dkey = self.dup_key_gen.gen_from_type(&node);
                 if key.1 == 0 {
-                    debug_assert!(dkey.is_empty());
+                    debug_assert!(dkey.is_default());
                     if value_type.default.is_some() {
                         bail!("duplicate default value type: {:?}", key);
                     }
@@ -193,7 +195,7 @@ impl ConversionMap {
                         relative_paths: std::iter::once(rpath).collect(),
                     });
                 } else {
-                    debug_assert!(!dkey.is_empty());
+                    debug_assert!(!dkey.is_default());
                     let index = key.1 - 1;
                     if index != value_type.variants.len() as u32 {
                         bail!("unexpected ordinal number for type registration: {:?}", key);