compiler: Rename builtin struct types

Author: tronical

internal/common/builtin_structs.rs

@@ -39,7 +39,7 @@ macro_rules! for_each_builtin_structs {
             /// On Windows, the Windows key is mapped to the meta modifier.
             #[derive(Copy, Eq)]
             struct KeyboardModifiers {
-                @name = NativePrivateType::KeyboardModifiers,
+                @name = BuiltinPrivateStruct::KeyboardModifiers,
                 export {
                     /// Indicates the Alt key on a keyboard.
                     alt: bool,
@@ -57,7 +57,7 @@ macro_rules! for_each_builtin_structs {
             /// Represents a Pointer event sent by the windowing system.
             /// This structure is passed to the `pointer-event` callback of the `TouchArea` element.
             struct PointerEvent {
-                @name = NativePrivateType::PointerEvent,
+                @name = BuiltinPrivateStruct::PointerEvent,
                 export {
                     /// The button that was pressed or released
                     button: PointerEventButton,
@@ -75,7 +75,7 @@ macro_rules! for_each_builtin_structs {
             /// Represents a Pointer scroll (or wheel) event sent by the windowing system.
             /// This structure is passed to the `scroll-event` callback of the `TouchArea` element.
             struct PointerScrollEvent {
-                @name = NativePrivateType::PointerScrollEvent,
+                @name = BuiltinPrivateStruct::PointerScrollEvent,
                 export {
                     /// The amount of pixel in the horizontal direction
                     delta_x: Coord,
@@ -90,7 +90,7 @@ macro_rules! for_each_builtin_structs {
 
             /// This structure is generated and passed to the key press and release callbacks of the `FocusScope` element.
             struct KeyEvent {
-                @name = NativePrivateType::KeyEvent,
+                @name = BuiltinPrivateStruct::KeyEvent,
                 export {
                     /// The unicode representation of the key pressed.
                     text: SharedString,
@@ -119,7 +119,7 @@ macro_rules! for_each_builtin_structs {
 
             /// This structure is passed to the callbacks of the `DropArea` element
             struct DropEvent {
-                @name = NativePrivateType::DropEvent,
+                @name = BuiltinPrivateStruct::DropEvent,
                 export {
                     /// The mime type of the data being dragged
                     mime_type: SharedString,
@@ -135,7 +135,7 @@ macro_rules! for_each_builtin_structs {
             /// Represents an item in a StandardListView and a StandardTableView.
             #[non_exhaustive]
             struct StandardListViewItem {
-                @name = NativePublicType::StandardListViewItem,
+                @name = BuiltinPublicStruct::StandardListViewItem,
                 export {
                     /// The text content of the item
                     text: SharedString,
@@ -147,7 +147,7 @@ macro_rules! for_each_builtin_structs {
             /// This is used to define the column and the column header of a TableView
             #[non_exhaustive]
             struct TableColumn {
-                @name = NativePrivateType::TableColumn,
+                @name = BuiltinPrivateStruct::TableColumn,
                 export {
                     /// The title of the column header
                     title: SharedString,
@@ -167,7 +167,7 @@ macro_rules! for_each_builtin_structs {
             /// Value of the state property
             /// A state is just the current state, but also has information about the previous state and the moment it changed
             struct StateInfo {
-                @name = NativePrivateType::StateInfo,
+                @name = BuiltinPrivateStruct::StateInfo,
                 export {
                     /// The current state value
                     current_state: i32,
@@ -182,7 +182,7 @@ macro_rules! for_each_builtin_structs {
 
             /// A structure to hold metrics of a font for a specified pixel size.
             struct FontMetrics {
-                @name = NativePrivateType::FontMetrics,
+                @name = BuiltinPrivateStruct::FontMetrics,
                 export {
                     /// The distance between the baseline and the top of the tallest glyph in the font.
                     ascent: Coord,
@@ -202,7 +202,7 @@ macro_rules! for_each_builtin_structs {
 
             /// An item in the menu of a menu bar or context menu
             struct MenuEntry {
-                @name = NativePrivateType::MenuEntry,
+                @name = BuiltinPrivateStruct::MenuEntry,
                 export {
                     /// The text of the menu entry
                     title: SharedString,

internal/compiler/builtins.slint

@@ -442,15 +442,15 @@ component MoveTo {
     in property <float> x;
     in property <float> y;
 
-    //-native_type:PathMoveTo
+    //-builtin_struct:PathMoveTo
     //-is_non_item_type
 }
 
 component LineTo {
     in property <float> x;
     in property <float> y;
 
-    //-native_type:PathLineTo
+    //-builtin_struct:PathLineTo
     //-is_non_item_type
 }
 
@@ -463,7 +463,7 @@ component ArcTo {
     in property <bool> large_arc;
     in property <bool> sweep;
 
-    //-native_type:PathArcTo
+    //-builtin_struct:PathArcTo
     //-is_non_item_type
 }
 
@@ -475,7 +475,7 @@ component CubicTo {
     in property <float> x;
     in property <float> y;
 
-    //-native_type:PathCubicTo
+    //-builtin_struct:PathCubicTo
     //-is_non_item_type
 }
 
@@ -485,12 +485,12 @@ component QuadraticTo {
     in property <float> x;
     in property <float> y;
 
-    //-native_type:PathQuadraticTo
+    //-builtin_struct:PathQuadraticTo
     //-is_non_item_type
 }
 
 component Close {
-    //-native_type:PathClose
+    //-builtin_struct:PathClose
     //-is_non_item_type
 }
 

internal/compiler/expression_tree.rs

@@ -2,7 +2,9 @@
 // SPDX-License-Identifier: GPL-3.0-only OR LicenseRef-Slint-Royalty-free-2.0 OR LicenseRef-Slint-Software-3.0
 
 use crate::diagnostics::{BuildDiagnostics, SourceLocation, Spanned};
-use crate::langtype::{BuiltinElement, EnumerationValue, Function, NativePublicType, Struct, Type};
+use crate::langtype::{
+    BuiltinElement, BuiltinPublicStruct, EnumerationValue, Function, Struct, Type,
+};
 use crate::layout::Orientation;
 use crate::lookup::LookupCtx;
 use crate::object_tree::*;
@@ -215,7 +217,7 @@ declare_builtin_function_types!(
             (SmolStr::new_static("alpha"), Type::Int32),
         ])
         .collect(),
-        name: NativePublicType::Color.into(),
+        name: BuiltinPublicStruct::Color.into(),
         rust_attributes: None,
     })),
     ColorHsvaStruct: (Type::Color) -> Type::Struct(Rc::new(Struct {
@@ -226,7 +228,7 @@ declare_builtin_function_types!(
             (SmolStr::new_static("alpha"), Type::Float32),
         ])
         .collect(),
-        name: NativePublicType::Color.into(),
+        name: BuiltinPublicStruct::Color.into(),
         rust_attributes: None,
     })),
     ColorBrighter: (Type::Brush, Type::Float32) -> Type::Brush,
@@ -240,7 +242,7 @@ declare_builtin_function_types!(
             (SmolStr::new_static("height"), Type::Int32),
         ])
         .collect(),
-        name: crate::langtype::NativePrivateType::Size.into(),
+        name: crate::langtype::BuiltinPrivateStruct::Size.into(),
         rust_attributes: None,
     })),
     ArrayLength: (Type::Model) -> Type::Int32,

internal/compiler/generator.rs

@@ -15,7 +15,7 @@ use std::rc::{Rc, Weak};
 
 use crate::CompilerConfiguration;
 use crate::expression_tree::{BindingExpression, Expression};
-use crate::langtype::{ElementType, NativePrivateType, NativeType, StructName};
+use crate::langtype::{BuiltinPrivateStruct, ElementType, StructName};
 use crate::namedreference::NamedReference;
 use crate::object_tree::{Component, Document, ElementRc};
 
@@ -423,7 +423,7 @@ pub fn for_each_const_properties(
                     .iter()
                     .filter(|(_, x)| {
                         x.property_type.is_property_type() &&
-                            !matches!( &x.property_type, crate::langtype::Type::Struct(s) if matches!(s.name, StructName::Native(NativeType::Private(NativePrivateType::StateInfo))))
+                            !matches!( &x.property_type, crate::langtype::Type::Struct(s) if matches!(s.name, StructName::BuiltinPrivate(BuiltinPrivateStruct::StateInfo)))
                     })
                     .map(|(k, _)| k.clone()),
             );

internal/compiler/generator/cpp.rs

@@ -459,7 +459,7 @@ pub mod cpp_ast {
 use crate::CompilerConfiguration;
 use crate::expression_tree::{BuiltinFunction, EasingCurve, MinMaxOp};
 use crate::langtype::{
-    Enumeration, EnumerationValue, NativeClass, NativePrivateType, NativePublicType, NativeType,
+    BuiltinPrivateStruct, BuiltinPublicStruct, Enumeration, EnumerationValue, NativeClass,
     StructName, Type,
 };
 use crate::layout::Orientation;
@@ -495,36 +495,28 @@ impl CppType for StructName {
         match self {
             StructName::None => return None,
             StructName::User { name, .. } => Some(ident(name)),
-            StructName::Native(native) => native.cpp_type(),
+            StructName::BuiltinPrivate(builtin_private) => builtin_private.cpp_type(),
+            StructName::BuiltinPublic(builtin_public) => builtin_public.cpp_type(),
         }
     }
 }
 
-impl CppType for NativeType {
-    fn cpp_type(&self) -> Option<SmolStr> {
-        match self {
-            NativeType::Private(native_private_type) => native_private_type.cpp_type(),
-            NativeType::Public(native_public_type) => native_public_type.cpp_type(),
-        }
-    }
-}
-
-impl CppType for NativePrivateType {
+impl CppType for BuiltinPrivateStruct {
     fn cpp_type(&self) -> Option<SmolStr> {
         let name: &'static str = self.into();
         match self {
-            NativePrivateType::PathMoveTo
-            | NativePrivateType::PathLineTo
-            | NativePrivateType::PathArcTo
-            | NativePrivateType::PathCubicTo
-            | NativePrivateType::PathQuadraticTo
-            | NativePrivateType::PathClose => Some(format_smolstr!("slint::private_api::{}", name)),
+            Self::PathMoveTo
+            | Self::PathLineTo
+            | Self::PathArcTo
+            | Self::PathCubicTo
+            | Self::PathQuadraticTo
+            | Self::PathClose => Some(format_smolstr!("slint::private_api::{}", name)),
             _ => Some(format_smolstr!("slint::cbindgen_private::{}", name)),
         }
     }
 }
 
-impl CppType for NativePublicType {
+impl CppType for BuiltinPublicStruct {
     fn cpp_type(&self) -> Option<SmolStr> {
         let name: &'static str = self.into();
         Some(format_smolstr!("slint::{}", name))

internal/compiler/generator/rust.rs

@@ -14,7 +14,7 @@ Some convention used in the generated code:
 
 use crate::CompilerConfiguration;
 use crate::expression_tree::{BuiltinFunction, EasingCurve, MinMaxOp, OperatorClass};
-use crate::langtype::{Enumeration, EnumerationValue, NativeType, Struct, StructName, Type};
+use crate::langtype::{Enumeration, EnumerationValue, Struct, StructName, Type};
 use crate::layout::Orientation;
 use crate::llr::{
     self, EvaluationContext as llr_EvaluationContext, EvaluationScope, Expression, ParentScope,
@@ -2593,7 +2593,7 @@ fn compile_expression(expr: &Expression, ctx: &EvaluationContext) -> TokenStream
             if ty.name.is_some() {
                 let name_tokens = struct_name_to_tokens(&ty.name).unwrap();
                 let keys = ty.fields.keys().map(|k| ident(k));
-                if matches!(&ty.name, StructName::Native(NativeType::Private(private_type)) if private_type.is_layout_data()) {
+                if matches!(&ty.name, StructName::BuiltinPrivate(private_type) if private_type.is_layout_data()) {
                     quote!(#name_tokens{#(#keys: #elem as _,)*})
                 } else {
                     quote!({ let mut the_struct = #name_tokens::default(); #(the_struct.#keys =  #elem as _;)* the_struct})
@@ -3409,18 +3409,16 @@ 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::Native(native_type) => match native_type {
-            crate::langtype::NativeType::Private(native_private_type) => {
-                let name: &'static str = native_private_type.into();
-                let name = format_ident!("{}", name);
-                Some(quote!(sp::#name))
-            }
-            crate::langtype::NativeType::Public(native_public_type) => {
-                let name: &'static str = native_public_type.into();
-                let name = format_ident!("{}", name);
-                Some(quote!(slint::#name))
-            }
-        },
+        StructName::BuiltinPrivate(builtin_private_struct) => {
+            let name: &'static str = builtin_private_struct.into();
+            let name = format_ident!("{}", name);
+            Some(quote!(sp::#name))
+        }
+        StructName::BuiltinPublic(builtin_public_struct) => {
+            let name: &'static str = builtin_public_struct.into();
+            let name = format_ident!("{}", name);
+            Some(quote!(slint::#name))
+        }
     }
 }