Extend smol_str usage

api/rs/build/Cargo.toml

@@ -26,3 +26,4 @@ i-slint-compiler = { workspace = true, features = ["default", "rust", "display-d
 spin_on = { workspace = true }
 thiserror = "1"
 toml_edit = { workspace = true }
+smol_str = "0.3.1"

api/rs/build/lib.rs

@@ -54,6 +54,7 @@ use std::collections::HashMap;
 use std::env;
 use std::io::{BufWriter, Write};
 use std::path::Path;
+use smol_str::SmolStr;
 
 use i_slint_compiler::diagnostics::BuildDiagnostics;
 
@@ -426,7 +427,7 @@ pub fn compile_with_output(
  }
 
  let mut compiler_config = config.config;
- compiler_config.translation_domain = std::env::var("CARGO_PKG_NAME").ok();
+ compiler_config.translation_domain = std::env::var("CARGO_PKG_NAME").as_ref().map(|s| SmolStr::new(s.as_str())).ok();
 
  let syntax_node = syntax_node.expect("diags contained no compilation errors");
 

api/rs/macros/Cargo.toml

@@ -27,3 +27,4 @@ i-slint-compiler = { workspace = true, features = ["default", "proc_macro_span",
 proc-macro2 = "1.0.17"
 quote = "1.0"
 spin_on = { workspace = true }
+smol_str = "0.3.1"

api/rs/macros/lib.rs

@@ -13,6 +13,7 @@ use i_slint_compiler::parser::SyntaxKind;
 use i_slint_compiler::*;
 use proc_macro::{Spacing, TokenStream, TokenTree};
 use quote::quote;
+use smol_str::SmolStr;
 
 /// Returns true if the two token are touching. For example the two token `foo`and `-` are touching if
 /// it was written like so in the source code: `foo-` but not when written like so `foo -`
@@ -407,7 +408,7 @@ pub fn slint(stream: TokenStream) -> TokenStream {
  }
 
  //println!("{:#?}", syntax_node);
- compiler_config.translation_domain = std::env::var("CARGO_PKG_NAME").ok();
+ compiler_config.translation_domain = std::env::var("CARGO_PKG_NAME").as_ref().map(|s| SmolStr::new(s.as_str())).ok();
  let (root_component, diag, loader) =
  spin_on::spin_on(compile_syntax_node(syntax_node, diag, compiler_config));
  //println!("{:#?}", tree);

internal/compiler/builtin_macros.rs

@@ -10,6 +10,7 @@ use crate::expression_tree::{
 };
 use crate::langtype::{EnumerationValue, Type};
 use crate::parser::NodeOrToken;
+use smol_str::{format_smolstr, ToSmolStr};
 
 /// Used for uniquely name some variables
 static COUNTER: std::sync::atomic::AtomicUsize = std::sync::atomic::AtomicUsize::new(1);
@@ -371,7 +372,7 @@ fn to_debug_string(
  ),
  op: '+',
  rhs: Box::new(Expression::StringLiteral(
- Type::UnitProduct(ty.as_unit_product().unwrap()).to_string(),
+ Type::UnitProduct(ty.as_unit_product().unwrap()).to_smolstr(),
  )),
  },
  Type::Bool => Expression::Condition {
@@ -380,14 +381,14 @@ fn to_debug_string(
  false_expr: Box::new(Expression::StringLiteral("false".into())),
  },
  Type::Struct { fields, .. } => {
- let local_object = format!(
+ let local_object = format_smolstr!(
  "debug_struct{}",
  COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
  );
  let mut string = None;
  for k in fields.keys() {
  let field_name =
- if string.is_some() { format!(", {}: ", k) } else { format!("{{ {}: ", k) };
+ if string.is_some() { format_smolstr!(", {}: ", k) } else { format_smolstr!("{{ {}: ", k) };
  let value = to_debug_string(
  Expression::StructFieldAccess {
  base: Box::new(Expression::ReadLocalVariable {
@@ -431,7 +432,7 @@ fn to_debug_string(
  name: local_object.into(),
  value: Box::new(expr),
  }];
- let mut cond = Expression::StringLiteral(format!("Error: invalid value for {}", ty));
+ let mut cond = Expression::StringLiteral(format_smolstr!("Error: invalid value for {}", ty));
  for (idx, val) in enu.values.iter().enumerate() {
  cond = Expression::Condition {
  condition: Box::new(Expression::BinaryExpression {

internal/compiler/expression_tree.rs

@@ -11,6 +11,7 @@ use core::cell::RefCell;
 use std::cell::Cell;
 use std::collections::HashMap;
 use std::rc::{Rc, Weak};
+use smol_str::SmolStr;
 
 // FIXME remove the pub
 pub use crate::namedreference::NamedReference;
@@ -44,7 +45,7 @@ pub enum BuiltinFunction {
  ClosePopupWindow,
  SetSelectionOffsets,
  /// A function that belongs to an item (such as TextInput's select-all function).
- ItemMemberFunction(String),
+ ItemMemberFunction(SmolStr),
  ItemFontMetrics,
  /// the "42".to_float()
  StringToFloat,
@@ -185,10 +186,10 @@ impl BuiltinFunction {
  BuiltinFunction::ColorRgbaStruct => Type::Function {
  return_type: Box::new(Type::Struct {
  fields: IntoIterator::into_iter([
- ("red".to_string(), Type::Int32),
- ("green".to_string(), Type::Int32),
- ("blue".to_string(), Type::Int32),
- ("alpha".to_string(), Type::Int32),
+ (SmolStr::new_static("red"), Type::Int32),
+ (SmolStr::new_static("green"), Type::Int32),
+ (SmolStr::new_static("blue"), Type::Int32),
+ (SmolStr::new_static("alpha"), Type::Int32),
  ])
  .collect(),
  name: Some("Color".into()),
@@ -200,10 +201,10 @@ impl BuiltinFunction {
  BuiltinFunction::ColorHsvaStruct => Type::Function {
  return_type: Box::new(Type::Struct {
  fields: IntoIterator::into_iter([
- ("hue".to_string(), Type::Float32),
- ("saturation".to_string(), Type::Float32),
- ("value".to_string(), Type::Float32),
- ("alpha".to_string(), Type::Float32),
+ (SmolStr::new_static("hue"), Type::Float32),
+ (SmolStr::new_static("saturation"), Type::Float32),
+ (SmolStr::new_static("value"), Type::Float32),
+ (SmolStr::new_static("alpha"), Type::Float32),
  ])
  .collect(),
  name: Some("Color".into()),
@@ -235,11 +236,11 @@ impl BuiltinFunction {
  BuiltinFunction::ImageSize => Type::Function {
  return_type: Box::new(Type::Struct {
  fields: IntoIterator::into_iter([
- ("width".to_string(), Type::Int32),
- ("height".to_string(), Type::Int32),
+ (SmolStr::new_static("width"), Type::Int32),
+ (SmolStr::new_static("height"), Type::Int32),
  ])
  .collect(),
- name: Some("Size".to_string()),
+ name: Some("Size".into()),
  node: None,
  rust_attributes: None,
  }),
@@ -576,7 +577,7 @@ pub enum Expression {
  Uncompiled(SyntaxNode),
 
  /// A string literal. The .0 is the content of the string, without the quotes
- StringLiteral(String),
+ StringLiteral(SmolStr),
  /// Number
  NumberLiteral(f64, Unit),
  /// Bool
@@ -636,22 +637,22 @@ pub enum Expression {
 
  /// Should be directly within a CodeBlock expression, and store the value of the expression in a local variable
  StoreLocalVariable {
- name: String,
+ name: SmolStr,
  value: Box<Expression>,
  },
 
  /// a reference to the local variable with the given name. The type system should ensure that a variable has been stored
  /// with this name and this type before in one of the statement of an enclosing codeblock
  ReadLocalVariable {
- name: String,
+ name: SmolStr,
  ty: Type,
  },
 
  /// Access to a field of the given name within a struct.
  StructFieldAccess {
  /// This expression should have [`Type::Struct`] type
  base: Box<Expression>,
- name: String,
+ name: SmolStr,
  },
 
  /// Access to a index within an array.
@@ -717,7 +718,7 @@ pub enum Expression {
  },
  Struct {
  ty: Type,
- values: HashMap<String, Expression>,
+ values: HashMap<SmolStr, Expression>,
  },
 
  PathData(Path),
@@ -1367,7 +1368,7 @@ impl Expression {
  | Type::LayoutCache => Expression::Invalid,
  Type::Void => Expression::CodeBlock(vec![]),
  Type::Float32 => Expression::NumberLiteral(0., Unit::None),
- Type::String => Expression::StringLiteral(String::new()),
+ Type::String => Expression::StringLiteral(SmolStr::default()),
  Type::Int32 | Type::Color | Type::UnitProduct(_) => Expression::Cast {
  from: Box::new(Expression::NumberLiteral(0., Unit::None)),
  to: ty.clone(),
@@ -1640,7 +1641,7 @@ pub enum EasingCurve {
 #[derive(Clone, Debug)]
 pub enum ImageReference {
  None,
- AbsolutePath(String),
+ AbsolutePath(SmolStr),
  EmbeddedData { resource_id: usize, extension: String },
  EmbeddedTexture { resource_id: usize },
 }