Intern some more common types

This is just for completeness, we "only" save ~13k allocations
with no measurable speed impact:

Before:
```
  Time (mean ± σ):      1.019 s ±  0.033 s    [User: 0.716 s, System: 0.203 s]
  Range (min … max):    0.957 s …  1.061 s    10 runs

        allocations:            2679001

```

After:
```
  Time (mean ± σ):      1.015 s ±  0.015 s    [User: 0.715 s, System: 0.201 s]
  Range (min … max):    0.997 s …  1.038 s    10 runs

        allocations:            2666889
```

Author: milianw

internal/compiler/expression_tree.rs

@@ -161,7 +161,7 @@ declare_builtin_function_types!(
     ItemFontMetrics: (Type::ElementReference) -> crate::typeregister::font_metrics_type(),
     StringToFloat: (Type::String) -> Type::Float32,
     StringIsFloat: (Type::String) -> Type::Bool,
-    ImplicitLayoutInfo(..): (Type::ElementReference) -> crate::layout::layout_info_type(),
+    ImplicitLayoutInfo(..): (Type::ElementReference) -> crate::typeregister::layout_info_type(),
     ColorRgbaStruct: (Type::Color) -> Type::Struct(Rc::new(Struct {
         fields: IntoIterator::into_iter([
             (SmolStr::new_static("red"), Type::Int32),
@@ -792,7 +792,7 @@ impl Expression {
             // invalid because the expression is unreachable
             Expression::ReturnStatement(_) => Type::Invalid,
             Expression::LayoutCacheAccess { .. } => Type::LogicalLength,
-            Expression::ComputeLayoutInfo(..) => crate::layout::layout_info_type(),
+            Expression::ComputeLayoutInfo(..) => crate::typeregister::layout_info_type(),
             Expression::SolveLayout(..) => Type::LayoutCache,
             Expression::MinMax { ty, .. } => ty.clone(),
             Expression::EmptyComponentFactory => Type::ComponentFactory,

internal/compiler/layout.rs

@@ -5,7 +5,7 @@
 
 use crate::diagnostics::BuildDiagnostics;
 use crate::expression_tree::*;
-use crate::langtype::{ElementType, PropertyLookupResult, Struct, Type};
+use crate::langtype::{ElementType, PropertyLookupResult, Type};
 use crate::object_tree::{Component, ElementRc};
 
 use smol_str::{format_smolstr, SmolStr};
@@ -485,24 +485,6 @@ impl BoxLayout {
     }
 }
 
-/// The [`Type`] for a runtime LayoutInfo structure
-pub fn layout_info_type() -> Type {
-    Type::Struct(Rc::new(Struct {
-        fields: ["min", "max", "preferred"]
-            .iter()
-            .map(|s| (SmolStr::new_static(s), Type::LogicalLength))
-            .chain(
-                ["min_percent", "max_percent", "stretch"]
-                    .iter()
-                    .map(|s| (SmolStr::new_static(s), Type::Float32)),
-            )
-            .collect(),
-        name: Some("slint::private_api::LayoutInfo".into()),
-        node: None,
-        rust_attributes: None,
-    }))
-}
-
 /// Get the implicit layout info of a particular element
 pub fn implicit_layout_info_call(elem: &ElementRc, orientation: Orientation) -> Expression {
     let mut elem_it = elem.clone();
@@ -538,7 +520,7 @@ pub fn implicit_layout_info_call(elem: &ElementRc, orientation: Orientation) ->
                 // hard-code the value for rectangle because many rectangle end up optimized away and we
                 // don't want to depend on the element.
                 Expression::Struct {
-                    ty: layout_info_type(),
+                    ty: crate::typeregister::layout_info_type(),
                     values: [("min", 0.), ("max", f32::MAX), ("preferred", 0.)]
                         .iter()
                         .map(|(s, v)| {

internal/compiler/llr/lower_expression.rs

@@ -500,7 +500,7 @@ fn compute_layout_info(
             llr_Expression::ExtraBuiltinFunctionCall {
                 function: "grid_layout_info".into(),
                 arguments: vec![cells, spacing, padding],
-                return_ty: crate::layout::layout_info_type(),
+                return_ty: crate::typeregister::layout_info_type(),
             }
         }
         crate::layout::Layout::BoxLayout(layout) => {
@@ -510,13 +510,13 @@ fn compute_layout_info(
                 llr_Expression::ExtraBuiltinFunctionCall {
                     function: "box_layout_info".into(),
                     arguments: vec![bld.cells, spacing, padding, bld.alignment],
-                    return_ty: crate::layout::layout_info_type(),
+                    return_ty: crate::typeregister::layout_info_type(),
                 }
             } else {
                 llr_Expression::ExtraBuiltinFunctionCall {
                     function: "box_layout_info_ortho".into(),
                     arguments: vec![bld.cells, padding],
-                    return_ty: crate::layout::layout_info_type(),
+                    return_ty: crate::typeregister::layout_info_type(),
                 }
             };
             match bld.compute_cells {
@@ -684,13 +684,7 @@ fn box_layout_data(
     let repeater_count =
         layout.elems.iter().filter(|i| i.element.borrow().repeated.is_some()).count();
 
-    let element_ty = Type::Struct(Rc::new(Struct {
-        fields: IntoIterator::into_iter([("constraint".into(), crate::layout::layout_info_type())])
-            .collect(),
-        name: Some("BoxLayoutCellData".into()),
-        node: None,
-        rust_attributes: None,
-    }));
+    let element_ty = crate::typeregister::box_layout_cell_data_type();
 
     if repeater_count == 0 {
         let cells = llr_Expression::Array {
@@ -702,7 +696,7 @@ fn box_layout_data(
                         get_layout_info(&li.element, ctx, &li.constraints, orientation);
                     make_struct(
                         "BoxLayoutCellData",
-                        [("constraint", crate::layout::layout_info_type(), layout_info)],
+                        [("constraint", crate::typeregister::layout_info_type(), layout_info)],
                     )
                 })
                 .collect(),
@@ -725,13 +719,13 @@ fn box_layout_data(
                     get_layout_info(&item.element, ctx, &item.constraints, orientation);
                 elements.push(Either::Left(make_struct(
                     "BoxLayoutCellData",
-                    [("constraint", crate::layout::layout_info_type(), layout_info)],
+                    [("constraint", crate::typeregister::layout_info_type(), layout_info)],
                 )));
             }
         }
         let cells = llr_Expression::ReadLocalVariable {
             name: "cells".into(),
-            ty: Type::Array(Rc::new(crate::layout::layout_info_type())),
+            ty: Type::Array(Rc::new(crate::typeregister::layout_info_type())),
         };
         BoxLayoutDataResult { alignment, cells, compute_cells: Some(("cells".into(), elements)) }
     }
@@ -755,7 +749,7 @@ fn grid_layout_cell_data(
                 make_struct(
                     "GridLayoutCellData",
                     [
-                        ("constraint", crate::layout::layout_info_type(), layout_info),
+                        ("constraint", crate::typeregister::layout_info_type(), layout_info),
                         ("col_or_row", Type::Int32, llr_Expression::NumberLiteral(col_or_row as _)),
                         ("span", Type::Int32, llr_Expression::NumberLiteral(span as _)),
                     ],
@@ -771,7 +765,7 @@ pub(super) fn grid_layout_cell_data_ty() -> Type {
         fields: IntoIterator::into_iter([
             (SmolStr::new_static("col_or_row"), Type::Int32),
             (SmolStr::new_static("span"), Type::Int32),
-            (SmolStr::new_static("constraint"), crate::layout::layout_info_type()),
+            (SmolStr::new_static("constraint"), crate::typeregister::layout_info_type()),
         ])
         .collect(),
         name: Some("GridLayoutCellData".into()),
@@ -831,7 +825,7 @@ pub fn get_layout_info(
             name: "layout_info".into(),
             value: layout_info.into(),
         };
-        let ty = crate::layout::layout_info_type();
+        let ty = crate::typeregister::layout_info_type();
         let fields = match &ty {
             Type::Struct(s) => &s.fields,
             _ => panic!(),
@@ -869,12 +863,7 @@ fn compile_path(path: &crate::expression_tree::Path, ctx: &ExpressionContext) ->
     fn llr_path_elements(elements: Vec<llr_Expression>) -> llr_Expression {
         llr_Expression::Cast {
             from: llr_Expression::Array {
-                element_ty: Type::Struct(Rc::new(Struct {
-                    fields: Default::default(),
-                    name: Some("PathElement".into()),
-                    node: None,
-                    rust_attributes: None,
-                })),
+                element_ty: crate::typeregister::path_element_type(),
                 values: elements,
                 as_model: false,
             }

internal/compiler/object_tree.rs

@@ -2703,12 +2703,12 @@ pub fn inject_element_as_repeated_element(repeated_element: &ElementRc, new_root
         let li_v = crate::layout::create_new_prop(
             &new_root,
             "layoutinfo-v",
-            crate::layout::layout_info_type(),
+            crate::typeregister::layout_info_type(),
         );
         let li_h = crate::layout::create_new_prop(
             &new_root,
             "layoutinfo-h",
-            crate::layout::layout_info_type(),
+            crate::typeregister::layout_info_type(),
         );
         let expr_h = crate::layout::implicit_layout_info_call(old_root, Orientation::Horizontal);
         let expr_v = crate::layout::implicit_layout_info_call(old_root, Orientation::Vertical);

internal/compiler/passes/default_geometry.rs

@@ -209,10 +209,16 @@ fn gen_layout_info_prop(elem: &ElementRc, diag: &mut BuildDiagnostics) {
         return;
     }
 
-    let li_v =
-        crate::layout::create_new_prop(elem, "layoutinfo-v", crate::layout::layout_info_type());
-    let li_h =
-        crate::layout::create_new_prop(elem, "layoutinfo-h", crate::layout::layout_info_type());
+    let li_v = crate::layout::create_new_prop(
+        elem,
+        "layoutinfo-v",
+        crate::typeregister::layout_info_type(),
+    );
+    let li_h = crate::layout::create_new_prop(
+        elem,
+        "layoutinfo-h",
+        crate::typeregister::layout_info_type(),
+    );
     elem.borrow_mut().layout_info_prop = Some((li_h.clone(), li_v.clone()));
     let mut expr_h = implicit_layout_info_call(elem, Orientation::Horizontal);
     let mut expr_v = implicit_layout_info_call(elem, Orientation::Vertical);
@@ -316,7 +322,7 @@ fn explicit_layout_info(e: &ElementRc, orientation: Orientation) -> Expression {
     }
     values.insert("min_percent".into(), Expression::NumberLiteral(0., Unit::None));
     values.insert("max_percent".into(), Expression::NumberLiteral(100., Unit::None));
-    Expression::Struct { ty: crate::layout::layout_info_type(), values }
+    Expression::Struct { ty: crate::typeregister::layout_info_type(), values }
 }
 
 /// Replace expression such as  `"width: 30%;` with `width: 0.3 * parent.width;`

internal/compiler/passes/lower_layout.rs

@@ -13,7 +13,7 @@ use crate::langtype::Type;
 use crate::layout::*;
 use crate::object_tree::*;
 use crate::typeloader::TypeLoader;
-use crate::typeregister::TypeRegister;
+use crate::typeregister::{layout_info_type, TypeRegister};
 use smol_str::format_smolstr;
 use std::cell::RefCell;
 use std::collections::HashSet;

internal/compiler/typeregister.rs

@@ -83,10 +83,27 @@ pub struct BuiltinTypes {
     pub strarg_callback_type: Type,
     pub logical_point_type: Type,
     pub font_metrics_type: Type,
+    pub layout_info_type: Type,
+    pub path_element_type: Type,
+    pub box_layout_cell_data_type: Type,
 }
 
 impl BuiltinTypes {
     fn new() -> Self {
+        let layout_info_type = Type::Struct(Rc::new(Struct {
+            fields: ["min", "max", "preferred"]
+                .iter()
+                .map(|s| (SmolStr::new_static(s), Type::LogicalLength))
+                .chain(
+                    ["min_percent", "max_percent", "stretch"]
+                        .iter()
+                        .map(|s| (SmolStr::new_static(s), Type::Float32)),
+                )
+                .collect(),
+            name: Some("slint::private_api::LayoutInfo".into()),
+            node: None,
+            rust_attributes: None,
+        }));
         Self {
             enums: BuiltinEnums::new(),
             logical_point_type: Type::Struct(Rc::new(Struct {
@@ -119,6 +136,20 @@ impl BuiltinTypes {
                 return_type: None,
                 args: vec![Type::String],
             })),
+            layout_info_type: layout_info_type.clone(),
+            path_element_type: Type::Struct(Rc::new(Struct {
+                fields: Default::default(),
+                name: Some("PathElement".into()),
+                node: None,
+                rust_attributes: None,
+            })),
+            box_layout_cell_data_type: Type::Struct(Rc::new(Struct {
+                fields: IntoIterator::into_iter([("constraint".into(), layout_info_type)])
+                    .collect(),
+                name: Some("BoxLayoutCellData".into()),
+                node: None,
+                rust_attributes: None,
+            })),
         }
     }
 }
@@ -633,3 +664,18 @@ pub fn logical_point_type() -> Type {
 pub fn font_metrics_type() -> Type {
     BUILTIN.with(|types| types.font_metrics_type.clone())
 }
+
+/// The [`Type`] for a runtime LayoutInfo structure
+pub fn layout_info_type() -> Type {
+    BUILTIN.with(|types| types.layout_info_type.clone())
+}
+
+/// The [`Type`] for a runtime PathElement structure
+pub fn path_element_type() -> Type {
+    BUILTIN.with(|types| types.path_element_type.clone())
+}
+
+/// The [`Type`] for a runtime BoxLayoutCellData structure
+pub fn box_layout_cell_data_type() -> Type {
+    BUILTIN.with(|types| types.box_layout_cell_data_type.clone())
+}