compiler: Move Struct's node field into the name enum

That guarantees the symmetry that if a struct is user defined, we're guaranteed to have a syntax node.

Author: tronical

api/node/rust/interpreter/component_compiler.rs

@@ -114,7 +114,7 @@ impl JsComponentCompiler {
     pub fn structs(&self, env: Env) -> HashMap<String, JsUnknown> {
         fn convert_type(env: &Env, ty: &Type) -> Option<(String, JsUnknown)> {
             match ty {
-                Type::Struct(s) if s.node.is_some() => {
+                Type::Struct(s) if s.node().is_some() => {
                     let name = s.name.slint_name().unwrap();
                     let struct_instance = to_js_unknown(
                         env,

api/python/slint/interpreter.rs

@@ -183,7 +183,7 @@ impl CompilationResult {
 
         for struct_or_enum in self.result.structs_and_enums(i_slint_core::InternalToken {}) {
             match struct_or_enum {
-                Type::Struct(s) if s.node.is_some() => {
+                Type::Struct(s) if s.node().is_some() => {
                     let struct_instance =
                         self.type_collection.struct_to_py(slint_interpreter::Struct::from_iter(
                             s.fields.iter().map(|(name, field_type)| {

internal/compiler/expression_tree.rs

@@ -216,7 +216,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: NativePublicType::Color.into(),
-        node: None,
         rust_attributes: None,
     })),
     ColorHsvaStruct: (Type::Color) -> Type::Struct(Rc::new(Struct {
@@ -228,7 +227,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: NativePublicType::Color.into(),
-        node: None,
         rust_attributes: None,
     })),
     ColorBrighter: (Type::Brush, Type::Float32) -> Type::Brush,
@@ -243,7 +241,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: crate::langtype::NativePrivateType::Size.into(),
-        node: None,
         rust_attributes: None,
     })),
     ArrayLength: (Type::Model) -> Type::Int32,

internal/compiler/generator/cpp.rs

@@ -495,7 +495,7 @@ impl CppType for StructName {
     fn cpp_type(&self) -> Option<SmolStr> {
         match self {
             StructName::None => return None,
-            StructName::User(user_struct) => Some(ident(user_struct)),
+            StructName::User { name, .. } => Some(ident(name)),
             StructName::Native(native) => native.cpp_type(),
         }
     }
@@ -921,8 +921,8 @@ pub fn generate_types(used_types: &[Type], config: &Config) -> File {
 
     for ty in used_types {
         match ty {
-            Type::Struct(s) if s.node.is_some() => {
-                generate_struct(&mut file, &s.name, &s.fields, s.node.as_ref().unwrap());
+            Type::Struct(s) if s.node().is_some() => {
+                generate_struct(&mut file, &s.name, &s.fields, s.node().unwrap());
             }
             Type::Enumeration(en) => {
                 generate_enum(&mut file, en);
@@ -4344,7 +4344,7 @@ pub fn generate_type_aliases(file: &mut File, doc: &Document) {
                 Some((&export.0.name, component.id.clone()))
             }
             Either::Right(ty) => match &ty {
-                Type::Struct(s) if s.node.is_some() => {
+                Type::Struct(s) if s.node().is_some() => {
                     Some((&export.0.name, s.name.cpp_type().unwrap()))
                 }
                 Type::Enumeration(en) => Some((&export.0.name, en.name.clone())),

internal/compiler/generator/cpp_live_preview.rs

@@ -500,8 +500,8 @@ fn convert_from_value_fn(ty: &Type) -> String {
 fn generate_value_conversions(file: &mut File, structs_and_enums: &[Type]) {
     for ty in structs_and_enums {
         match ty {
-            Type::Struct(s) if s.node.is_some() => {
-                let StructName::User(struct_name) = &s.name else {
+            Type::Struct(s) if s.node().is_some() => {
+                let StructName::User { name: struct_name, .. } = &s.name else {
                     return;
                 };
                 let name = ident(&struct_name);

internal/compiler/generator/rust.rs

@@ -280,15 +280,16 @@ pub fn generate_types(used_types: &[Type]) -> (Vec<Ident>, TokenStream) {
         .iter()
         .filter_map(|ty| match ty {
             Type::Struct(s) => match s.as_ref() {
-                Struct {
-                    fields,
-                    name: StructName::User(user_name),
-                    node: Some(_),
-                    rust_attributes,
-                } => Some((
-                    ident(user_name),
-                    generate_struct(&StructName::User(user_name.clone()), fields, rust_attributes),
-                )),
+                Struct { fields, name: StructName::User { name, node }, rust_attributes } => {
+                    Some((
+                        ident(name),
+                        generate_struct(
+                            &StructName::User { name: name.clone(), node: node.clone() },
+                            fields,
+                            rust_attributes,
+                        ),
+                    ))
+                }
                 _ => None,
             },
             Type::Enumeration(en) => Some((ident(&en.name), generate_enum(en))),
@@ -3407,7 +3408,7 @@ fn compile_builtin_function_call(
 fn struct_name_to_tokens(name: &StructName) -> Option<proc_macro2::TokenStream> {
     match name {
         StructName::None => None,
-        StructName::User(name) => Some(proc_macro2::TokenTree::from(ident(name)).into()),
+        StructName::User { name, .. } => Some(proc_macro2::TokenTree::from(ident(name)).into()),
         StructName::Native(native_type) => match native_type {
             crate::langtype::NativeType::Private(native_private_type) => {
                 let name: &'static str = native_private_type.into();
@@ -3645,9 +3646,9 @@ pub fn generate_named_exports(exports: &crate::object_tree::Exports) -> Vec<Toke
                 }
             }
             Either::Right(ty) => match &ty {
-                Type::Struct(s) if s.node.is_some() => {
-                    if let StructName::User(user_name) = &s.name
-                        && *user_name == export.0.name
+                Type::Struct(s) if s.node().is_some() => {
+                    if let StructName::User { name, .. } = &s.name
+                        && *name == export.0.name
                     {
                         None
                     } else {

internal/compiler/generator/rust_live_preview.rs

@@ -396,7 +396,7 @@ fn generate_value_conversions(used_types: &[Type]) -> TokenStream {
         .iter()
         .filter_map(|ty| match ty {
             Type::Struct(s) => match s.as_ref() {
-                Struct { fields, name: StructName::User(name), node: Some(_), .. } => {
+                Struct { fields, name: StructName::User { name, .. }, .. } => {
                     let ty = ident(name);
                     let convert_to_value = fields.values().map(convert_to_value_fn);
                     let convert_from_value = fields.values().map(convert_from_value_fn);

internal/compiler/langtype.rs

@@ -864,19 +864,36 @@ pub struct Function {
     pub arg_names: Vec<SmolStr>,
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub enum StructName {
     None,
     /// When declared in .slint as  `struct Foo { }`, then the name is "Foo"
-    User(SmolStr),
+    User {
+        name: SmolStr,
+        /// When declared in .slint, this is the node of the declaration.
+        node: syntax_nodes::ObjectType,
+    },
     Native(NativeType),
 }
 
+impl PartialEq for StructName {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (
+                Self::User { name: l_user_name, node: _ },
+                Self::User { name: r_user_name, node: _ },
+            ) => l_user_name == r_user_name,
+            (Self::Native(l0), Self::Native(r0)) => l0 == r0,
+            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
+        }
+    }
+}
+
 impl StructName {
     pub fn slint_name(&self) -> Option<SmolStr> {
         match self {
             StructName::None => None,
-            StructName::User(name) => Some(name.clone()),
+            StructName::User { name, .. } => Some(name.clone()),
             StructName::Native(native_type) => native_type.slint_name(),
         }
     }
@@ -913,12 +930,19 @@ impl From<NativePublicType> for StructName {
 pub struct Struct {
     pub fields: BTreeMap<SmolStr, Type>,
     pub name: StructName,
-    /// When declared in .slint, this is the node of the declaration.
-    pub node: Option<syntax_nodes::ObjectType>,
     /// derived
     pub rust_attributes: Option<Vec<SmolStr>>,
 }
 
+impl Struct {
+    pub fn node(&self) -> Option<&syntax_nodes::ObjectType> {
+        match &self.name {
+            StructName::User { node, .. } => Some(node),
+            _ => None,
+        }
+    }
+}
+
 impl Display for Struct {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if let Some(name) = &self.name.slint_name() {

internal/compiler/llr/lower_expression.rs

@@ -527,7 +527,6 @@ pub fn lower_animation(a: &PropertyAnimation, ctx: &mut ExpressionLoweringCtx<'_
         Rc::new(Struct {
             fields: animation_fields().collect(),
             name: NativePrivateType::PropertyAnimation.into(),
-            node: None,
             rust_attributes: None,
         })
     }
@@ -565,7 +564,6 @@ pub fn lower_animation(a: &PropertyAnimation, ctx: &mut ExpressionLoweringCtx<'_
                     ])
                     .collect(),
                     name: StructName::None,
-                    node: None,
                     rust_attributes: None,
                 }),
                 values: IntoIterator::into_iter([
@@ -874,7 +872,6 @@ pub(super) fn grid_layout_cell_data_ty() -> Type {
         ])
         .collect(),
         name: NativePrivateType::GridLayoutCellData.into(),
-        node: None,
         rust_attributes: None,
     }))
 }
@@ -997,7 +994,6 @@ fn compile_path(
                                 .clone()
                                 .expect("Unknown path element encountered"),
                         ),
-                        node: None,
                         rust_attributes: None,
                     });
 
@@ -1049,7 +1045,6 @@ fn compile_path(
                         ])
                         .collect(),
                         name: StructName::None,
-                        node: None,
                         rust_attributes: None,
                     }),
                     values: IntoIterator::into_iter([
@@ -1098,7 +1093,6 @@ pub fn make_struct(
         ty: Rc::new(Struct {
             fields,
             name: StructName::Native(name.into()),
-            node: None,
             rust_attributes: None,
         }),
         values,

internal/compiler/llr/lower_to_item_tree.rs

@@ -616,7 +616,7 @@ fn lower_geometry(
             .insert(f.into(), super::Expression::PropertyReference(ctx.map_property_reference(v)));
     }
     super::Expression::Struct {
-        ty: Rc::new(Struct { fields, name: StructName::None, node: None, rust_attributes: None }),
+        ty: Rc::new(Struct { fields, name: StructName::None, rust_attributes: None }),
         values,
     }
 }