LLR: A pass to remove unused properties from the LLR

Author: ogoffart

internal/compiler/generator/cpp.rs

@@ -1973,7 +1973,7 @@ fn generate_sub_component(
         file.declarations.push(Declaration::Struct(menu_struct));
     }
 
-    for property in component.properties.iter().filter(|p| p.use_count.get() > 0) {
+    for property in component.properties.iter() {
         let cpp_name = ident(&property.name);
 
         let ty = if let Type::Callback(callback) = &property.ty {
@@ -2116,15 +2116,11 @@ fn generate_sub_component(
 
     let mut properties_init_code = Vec::new();
     for (prop, expression) in &component.property_init {
-        if expression.use_count.get() > 0 && component.prop_used(prop, root) {
-            handle_property_init(prop, expression, &mut properties_init_code, &ctx)
-        }
+        handle_property_init(prop, expression, &mut properties_init_code, &ctx)
     }
     for prop in &component.const_properties {
-        if component.prop_used(&prop.clone().into(), root) {
-            let p = access_local_member(prop, &ctx);
-            properties_init_code.push(format!("{p}.set_constant();"));
-        }
+        let p = access_local_member(prop, &ctx);
+        properties_init_code.push(format!("{p}.set_constant();"));
     }
 
     for item in &component.items {
@@ -2621,7 +2617,7 @@ fn generate_global(
 ) {
     let mut global_struct = Struct { name: ident(&global.name), ..Default::default() };
 
-    for property in global.properties.iter().filter(|p| p.use_count.get() > 0) {
+    for property in global.properties.iter() {
         let cpp_name = ident(&property.name);
 
         let ty = if let Type::Callback(callback) = &property.ty {
@@ -2653,10 +2649,6 @@ fn generate_global(
     );
 
     for (property_index, expression) in global.init_values.iter_enumerated() {
-        if global.properties[property_index].use_count.get() == 0 {
-            continue;
-        }
-
         if let Some(expression) = expression.as_ref() {
             handle_property_init(
                 &llr::LocalMemberReference::from(property_index).into(),

internal/compiler/generator/rust.rs

@@ -812,7 +812,7 @@ fn generate_sub_component(
     let mut declared_callbacks_types = vec![];
     let mut declared_callbacks_ret = vec![];
 
-    for property in component.properties.iter().filter(|p| p.use_count.get() > 0) {
+    for property in component.properties.iter() {
         let prop_ident = ident(&property.name);
         if let Type::Callback(callback) = &property.ty {
             let callback_args =
@@ -1146,15 +1146,11 @@ fn generate_sub_component(
     }
 
     for (prop, expression) in &component.property_init {
-        if expression.use_count.get() > 0 && component.prop_used(prop, root) {
-            handle_property_init(prop, expression, &mut init, &ctx)
-        }
+        handle_property_init(prop, expression, &mut init, &ctx)
     }
     for prop in &component.const_properties {
-        if component.prop_used(&prop.clone().into(), root) {
-            let rust_property = access_local_member(prop, &ctx);
-            init.push(quote!(#rust_property.set_constant();))
-        }
+        let rust_property = access_local_member(prop, &ctx);
+        init.push(quote!(#rust_property.set_constant();))
     }
 
     let parent_component_type = parent_ctx.iter().map(|parent| {
@@ -1447,7 +1443,7 @@ fn generate_global(
     let mut declared_callbacks_types = vec![];
     let mut declared_callbacks_ret = vec![];
 
-    for property in global.properties.iter().filter(|p| p.use_count.get() > 0) {
+    for property in global.properties.iter() {
         let prop_ident = ident(&property.name);
         if let Type::Callback(callback) = &property.ty {
             let callback_args =
@@ -1483,9 +1479,6 @@ fn generate_global(
     let declared_functions = generate_functions(global.functions.as_ref(), &ctx);
 
     for (property_index, expression) in global.init_values.iter_enumerated() {
-        if global.properties[property_index].use_count.get() == 0 {
-            continue;
-        }
         if let Some(expression) = expression.as_ref() {
             handle_property_init(
                 &llr::LocalMemberReference::from(property_index).into(),
@@ -1496,9 +1489,6 @@ fn generate_global(
         }
     }
     for (property_index, cst) in global.const_properties.iter_enumerated() {
-        if global.properties[property_index].use_count.get() == 0 {
-            continue;
-        }
         if *cst {
             let rust_property = access_local_member(&property_index.into(), &ctx);
             init.push(quote!(#rust_property.set_constant();))

internal/compiler/llr.rs

@@ -15,9 +15,11 @@ pub mod pretty_print;
 pub mod optim_passes {
     pub mod count_property_use;
     mod inline_expressions;
+    mod remove_unused;
 
-    pub fn run_passes(root: &super::CompilationUnit) {
+    pub fn run_passes(root: &mut super::CompilationUnit) {
         count_property_use::count_property_use(root);
         inline_expressions::inline_simple_expressions(root);
+        remove_unused::remove_unused(root);
     }
 }

internal/compiler/llr/expression.rs

@@ -442,6 +442,12 @@ impl Expression {
         self.visit(|e| e.visit_recursive(visitor));
     }
 
+    /// Visit itself and each sub expression recursively
+    pub fn visit_recursive_mut(&mut self, visitor: &mut dyn FnMut(&mut Self)) {
+        visitor(self);
+        self.visit_mut(|e| e.visit_recursive_mut(visitor));
+    }
+
     pub fn visit_property_references(
         &self,
         ctx: &EvaluationContext,

internal/compiler/llr/item_tree.rs

@@ -31,7 +31,7 @@ impl PropertyIdx {
     pub const REPEATER_INDEX: Self = Self(1);
 }
 
-#[derive(Debug, Clone, derive_more::Deref)]
+#[derive(Debug, Clone, derive_more::Deref, derive_more::DerefMut)]
 pub struct MutExpression(RefCell<Expression>);
 
 impl From<Expression> for MutExpression {
@@ -399,26 +399,6 @@ impl SubComponent {
         }
         count
     }
-
-    /// Return if a local property is used. (unused property shouldn't be generated)
-    pub fn prop_used(&self, prop: &MemberReference, cu: &CompilationUnit) -> bool {
-        let MemberReference::Relative { parent_level, local_reference } = prop else {
-            return true;
-        };
-        if *parent_level != 0 {
-            return true;
-        }
-        if let LocalMemberIndex::Property(property_index) = &local_reference.reference {
-            let mut sc = self;
-            for i in &local_reference.sub_component_path {
-                sc = &cu.sub_components[sc.sub_components[*i].ty];
-            }
-            if sc.properties[*property_index].use_count.get() == 0 {
-                return false;
-            }
-        }
-        true
-    }
 }
 
 #[derive(Debug)]

internal/compiler/llr/lower_to_item_tree.rs

@@ -86,7 +86,7 @@ pub fn lower_to_item_tree(
         PopupMenu { item_tree, sub_menu, activated, close, entries }
     });
 
-    let root = CompilationUnit {
+    let mut root = CompilationUnit {
         public_components,
         globals,
         sub_components: state.sub_components.into_iter().map(|sc| sc.sub_component).collect(),
@@ -102,7 +102,7 @@ pub fn lower_to_item_tree(
         #[cfg(feature = "bundle-translations")]
         translations: state.translation_builder.map(|x| x.result()),
     };
-    super::optim_passes::run_passes(&root);
+    super::optim_passes::run_passes(&mut root);
     root
 }