Compiler: Remove Struct::rust_attributes and make it an error if @rust-attr(...) doesn't lex (#10118)

The `rust_attributes` in langtype::Struct is a bit wierd as it is only
used for rust code generation, yet is stored in every Struct.
Instead, read the `node` while doing code generation like we do in C++.

The previous code was ignoring the error lexing the code in the
attribute, and now we add a compile_error!

Author: ogoffart

api/rs/slint/compile_fail_tests.rs

@@ -26,6 +26,30 @@ mod x {
 #[cfg(doctest)]
 const basic: u32 = 0;
 
+/**
+Test that invalid rust-attr are compilation error
+
+This should result in a `compile_error!("Error parsing @rust-attr for struct 'Foo' declared at tests/invalid_rust_attr.slint:4:12"`
+```compile_fail
+use slint::*;
+slint!{
+    export { Foo } from "tests/invalid_rust_attr.slint";
+    export component Hello inherits Window { }
+}
+```
+
+But Foo is not used/generated, then we do not detect the error
+(Having the test here to test that the previous test would otherwise work, but it would also be ok to detect the error and make it an actual slint compile error)
+```
+use slint::*;
+slint!{
+    import { Foo } from "tests/invalid_rust_attr.slint";
+    export component Hello inherits Window { }
+}
+```
+*/
+const INVALID_RUST_ATTR: () = ();
+
 #[cfg(doctest)]
 #[doc = include_str!("README.md")]
 const CHECK_README_EXAMPLES: () = ();

api/rs/slint/tests/invalid_rust_attr.slint

@@ -0,0 +1,5 @@
+// Copyright © SixtyFPS GmbH <[email protected]>
+// SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
+
+@rust-attr("Doesn't Lex in rust \{"🦞"}")
+export struct Foo { int: int }

internal/compiler/diagnostics.rs

@@ -324,6 +324,17 @@ impl std::fmt::Display for Diagnostic {
     }
 }
 
+impl std::fmt::Display for SourceLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(sf) = &self.source_file {
+            let (line, col) = sf.line_column(self.span.offset, ByteFormat::Utf8);
+            write!(f, "{}:{line}:{col}", sf.path.display())
+        } else {
+            write!(f, "<unknown>")
+        }
+    }
+}
+
 pub fn diagnostic_line_column_with_format(
     diagnostic: &Diagnostic,
     format: ByteFormat,

internal/compiler/expression_tree.rs

@@ -218,7 +218,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: BuiltinPublicStruct::Color.into(),
-        rust_attributes: None,
     })),
     ColorHsvaStruct: (Type::Color) -> Type::Struct(Rc::new(Struct {
         fields: IntoIterator::into_iter([
@@ -229,7 +228,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: BuiltinPublicStruct::Color.into(),
-        rust_attributes: None,
     })),
     ColorBrighter: (Type::Brush, Type::Float32) -> Type::Brush,
     ColorDarker: (Type::Brush, Type::Float32) -> Type::Brush,
@@ -243,7 +241,6 @@ declare_builtin_function_types!(
         ])
         .collect(),
         name: crate::langtype::BuiltinPrivateStruct::Size.into(),
-        rust_attributes: None,
     })),
     ArrayLength: (Type::Model) -> Type::Int32,
     Rgb: (Type::Int32, Type::Int32, Type::Int32, Type::Float32) -> Type::Color,

internal/compiler/generator/rust.rs

@@ -280,15 +280,8 @@ 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 { name, node }, rust_attributes } => {
-                    Some((
-                        ident(name),
-                        generate_struct(
-                            &StructName::User { name: name.clone(), node: node.clone() },
-                            fields,
-                            rust_attributes,
-                        ),
-                    ))
+                Struct { fields, name: struct_name @ StructName::User { name, .. } } => {
+                    Some((ident(name), generate_struct(struct_name, fields)))
                 }
                 _ => None,
             },
@@ -519,25 +512,27 @@ fn generate_shared_globals(
     }
 }
 
-fn generate_struct(
-    name: &StructName,
-    fields: &BTreeMap<SmolStr, Type>,
-    rust_attributes: &Option<Vec<SmolStr>>,
-) -> TokenStream {
+fn generate_struct(name: &StructName, fields: &BTreeMap<SmolStr, Type>) -> TokenStream {
     let component_id = struct_name_to_tokens(&name).unwrap();
     let (declared_property_vars, declared_property_types): (Vec<_>, Vec<_>) =
         fields.iter().map(|(name, ty)| (ident(name), rust_primitive_type(ty).unwrap())).unzip();
 
-    let attributes = if let Some(feature) = rust_attributes {
-        let attr =
-            feature.iter().map(|f| match TokenStream::from_str(format!(r#"#[{f}]"#).as_str()) {
-                Ok(eval) => eval,
-                Err(_) => quote! {},
-            });
-        quote! { #(#attr)* }
-    } else {
-        quote! {}
-    };
+    let StructName::User { name, node } = name else { unreachable!("generating non-user struct") };
+
+    let attributes = node
+        .parent()
+        .and_then(crate::parser::syntax_nodes::StructDeclaration::new)
+        .and_then(|d| d.AtRustAttr())
+        .map(|n| match TokenStream::from_str(&n.text().to_string()) {
+            Ok(t) => quote!(#[#t]),
+            Err(_) => {
+                let source_location = crate::diagnostics::Spanned::to_source_location(&n);
+                let error = format!(
+                    "Error parsing @rust-attr for struct '{name}' declared at {source_location}"
+                );
+                quote!(compile_error!(#error);)
+            }
+        });
 
     quote! {
         #attributes

internal/compiler/langtype.rs

@@ -931,8 +931,6 @@ impl From<BuiltinPublicStruct> for StructName {
 pub struct Struct {
     pub fields: BTreeMap<SmolStr, Type>,
     pub name: StructName,
-    /// derived
-    pub rust_attributes: Option<Vec<SmolStr>>,
 }
 
 impl Struct {

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: BuiltinPrivateStruct::PropertyAnimation.into(),
-            rust_attributes: None,
         })
     }
 
@@ -564,7 +563,6 @@ pub fn lower_animation(a: &PropertyAnimation, ctx: &mut ExpressionLoweringCtx<'_
                     ])
                     .collect(),
                     name: StructName::None,
-                    rust_attributes: None,
                 }),
                 values: IntoIterator::into_iter([
                     (SmolStr::new_static("0"), get_anim),
@@ -872,7 +870,6 @@ pub(super) fn grid_layout_cell_data_ty() -> Type {
         ])
         .collect(),
         name: BuiltinPrivateStruct::GridLayoutCellData.into(),
-        rust_attributes: None,
     }))
 }
 
@@ -994,7 +991,6 @@ fn compile_path(
                                 .clone()
                                 .expect("path elements should have a native_type"),
                         ),
-                        rust_attributes: None,
                     });
 
                     llr_Expression::Struct {
@@ -1045,7 +1041,6 @@ fn compile_path(
                         ])
                         .collect(),
                         name: StructName::None,
-                        rust_attributes: None,
                     }),
                     values: IntoIterator::into_iter([
                         (
@@ -1089,8 +1084,5 @@ pub fn make_struct(
         values.insert(SmolStr::new(name), expr);
     }
 
-    llr_Expression::Struct {
-        ty: Rc::new(Struct { fields, name: name.into(), rust_attributes: None }),
-        values,
-    }
+    llr_Expression::Struct { ty: Rc::new(Struct { fields, name: name.into() }), values }
 }

internal/compiler/llr/lower_to_item_tree.rs

@@ -615,10 +615,7 @@ fn lower_geometry(
         values
             .insert(f.into(), super::Expression::PropertyReference(ctx.map_property_reference(v)));
     }
-    super::Expression::Struct {
-        ty: Rc::new(Struct { fields, name: StructName::None, rust_attributes: None }),
-        values,
-    }
+    super::Expression::Struct { ty: Rc::new(Struct { fields, name: StructName::None }), values }
 }
 
 fn get_property_analysis(elem: &ElementRc, p: &str) -> crate::object_tree::PropertyAnalysis {

internal/compiler/object_tree.rs

@@ -98,12 +98,10 @@ impl Document {
                               diag: &mut BuildDiagnostics,
                               local_registry: &mut TypeRegister,
                               inner_types: &mut Vec<Type>| {
-            let rust_attributes = n.AtRustAttr().map(|child| vec![child.text().to_smolstr()]);
             let ty = type_struct_from_node(
                 n.ObjectType(),
                 diag,
                 local_registry,
-                rust_attributes,
                 parser::identifier_text(&n.DeclaredIdentifier()),
             );
             assert!(matches!(ty, Type::Struct(_)));
@@ -2003,7 +2001,7 @@ pub fn type_from_node(
         }
         prop_type
     } else if let Some(object_node) = node.ObjectType() {
-        type_struct_from_node(object_node, diag, tr, None, None)
+        type_struct_from_node(object_node, diag, tr, None)
     } else if let Some(array_node) = node.ArrayType() {
         Type::Array(Rc::new(type_from_node(array_node.Type(), diag, tr)))
     } else {
@@ -2017,7 +2015,6 @@ pub fn type_struct_from_node(
     object_node: syntax_nodes::ObjectType,
     diag: &mut BuildDiagnostics,
     tr: &TypeRegister,
-    rust_attributes: Option<Vec<SmolStr>>,
     name: Option<SmolStr>,
 ) -> Type {
     let fields = object_node
@@ -2032,7 +2029,6 @@ pub fn type_struct_from_node(
     Type::Struct(Rc::new(Struct {
         fields,
         name: name.map_or(StructName::None, |name| StructName::User { name, node: object_node }),
-        rust_attributes,
     }))
 }
 

internal/compiler/passes/compile_paths.rs

@@ -164,7 +164,6 @@ fn compile_path_from_string_literal(
         ])
         .collect(),
         name: BuiltinPrivateStruct::Point.into(),
-        rust_attributes: None,
     });
 
     let mut points = Vec::new();