SQUASH: Rework the element id to be a hash based on filename

and position iof the LBrace token.

Author: hunger

internal/compiler/expression_tree.rs

@@ -1423,7 +1423,7 @@ impl Expression {
     pub fn ignore_debug_hooks(&self) -> &Expression {
         match self {
             Expression::DebugHook { expression, .. } => expression.as_ref(),
-            _ => return self,
+            _ => self,
         }
     }
 }

internal/compiler/lib.rs

@@ -149,7 +149,7 @@ pub struct CompilerConfiguration {
     pub debug_info: bool,
 
     /// Generate debug hooks to inspect/override properties.
-    pub debug_hooks: bool,
+    pub debug_hooks: Option<std::hash::RandomState>,
 
     pub components_to_generate: ComponentSelection,
 
@@ -229,7 +229,7 @@ impl CompilerConfiguration {
             translation_domain: None,
             cpp_namespace,
             debug_info,
-            debug_hooks: false,
+            debug_hooks: None,
             components_to_generate: ComponentSelection::ExportedWindows,
             #[cfg(feature = "software-renderer")]
             font_cache: Default::default(),

internal/compiler/object_tree.rs

@@ -641,9 +641,11 @@ pub struct ElementDebugInfo {
     // The id qualified with the enclosing component name. Given `foo := Bar {}` this is `EnclosingComponent::foo`
     pub qualified_id: Option<SmolStr>,
     pub type_name: String,
-    // Hold an id for each element that is unique during this build.
-    // It helps to cross-reference the element in the different build stages the LSP has to deal with.
-    pub element_id: u64,
+    // Hold an id for each element that is unique during this build, based on the source file and
+    // the offset of the `LBrace` token.
+    //
+    // This helps to cross-reference the element in the different build stages the LSP has to deal with.
+    pub element_hash: u64,
     pub node: syntax_nodes::Element,
     // Field to indicate whether this element was a layout that had
     // been lowered into a rectangle in the lower_layouts pass.
@@ -1000,7 +1002,7 @@ impl Element {
             base_type,
             debug: vec![ElementDebugInfo {
                 qualified_id,
-                element_id: 0,
+                element_hash: 0,
                 type_name,
                 node: node.clone(),
                 layout: None,

internal/compiler/passes.rs

@@ -93,8 +93,6 @@ pub async fn run_passes(
 
     let global_type_registry = type_loader.global_type_registry.clone();
 
-    inject_debug_hooks::inject_debug_hooks(doc, type_loader);
-
     run_import_passes(doc, type_loader, diag);
     check_public_api::check_public_api(doc, &type_loader.compiler_config, diag);
 
@@ -327,6 +325,7 @@ pub fn run_import_passes(
     type_loader: &crate::typeloader::TypeLoader,
     diag: &mut crate::diagnostics::BuildDiagnostics,
 ) {
+    inject_debug_hooks::inject_debug_hooks(doc, type_loader);
     infer_aliases_types::resolve_aliases(doc, diag);
     resolving::resolve_expressions(doc, type_loader, diag);
     purity_check::purity_check(doc, diag);

internal/compiler/passes/const_propagation.rs

@@ -207,7 +207,6 @@ fn simplify_expression(expr: &mut Expression) -> bool {
         Expression::LayoutCacheAccess { .. } => false,
         Expression::SolveLayout { .. } => false,
         Expression::ComputeLayoutInfo { .. } => false,
-        Expression::DebugHook { .. } => false, // This is not const by design
         _ => {
             let mut result = true;
             expr.visit_mut(|expr| result &= simplify_expression(expr));

internal/compiler/passes/inject_debug_hooks.rs

@@ -5,51 +5,68 @@
 
 use crate::{expression_tree, object_tree, typeloader};
 
-pub fn inject_debug_hooks(
-    doc: &mut object_tree::Document,
-    type_loader: &mut typeloader::TypeLoader,
-) {
-    if !type_loader.compiler_config.debug_info {
+pub fn inject_debug_hooks(doc: &object_tree::Document, type_loader: &typeloader::TypeLoader) {
+    let Some(random_state) = &type_loader.compiler_config.debug_hooks else {
         return;
-    }
-
-    let mut counter = 1_u64;
+    };
 
     doc.visit_all_used_components(|component| {
         object_tree::recurse_elem_including_sub_components(component, &(), &mut |e, &()| {
-            process_element(e, counter, &type_loader.compiler_config);
-            counter += 1;
+            process_element(e, random_state);
         })
     });
 }
 
-fn property_id(counter: u64, name: &smol_str::SmolStr) -> smol_str::SmolStr {
-    smol_str::format_smolstr!("?{counter}-{name}")
+fn property_id(element_id: u64, name: &smol_str::SmolStr) -> smol_str::SmolStr {
+    smol_str::format_smolstr!("?{element_id}-{name}")
 }
 
-fn process_element(
-    element: &object_tree::ElementRc,
-    counter: u64,
-    config: &crate::CompilerConfiguration,
-) {
+fn calculate_element_hash(
+    elem: &object_tree::Element,
+    random_state: &std::hash::RandomState,
+) -> u64 {
+    let node = &elem.debug.first().expect("There was one element a moment ago").node;
+
+    let elem_path = node.source_file.path();
+    let elem_offset = node
+        .child_token(crate::parser::SyntaxKind::LBrace)
+        .expect("All elements have a opening Brace")
+        .text_range()
+        .start();
+
+    use std::hash::{BuildHasher, Hasher};
+    let mut hasher = random_state.build_hasher();
+    hasher.write(elem_path.as_os_str().as_encoded_bytes());
+    hasher.write_u32(elem_offset.into());
+    hasher.finish()
+}
+
+fn process_element(element: &object_tree::ElementRc, random_state: &std::hash::RandomState) {
     let mut elem = element.borrow_mut();
-    assert_eq!(elem.debug.len(), 1); // We did not merge Elements yet and we have debug info!
-
-    if config.debug_hooks {
-        elem.bindings.iter().for_each(|(name, be)| {
-            let expr = std::mem::take(&mut be.borrow_mut().expression);
-            be.borrow_mut().expression = {
-                let stripped = super::ignore_debug_hooks(&expr);
-                if matches!(stripped, expression_tree::Expression::Invalid) {
-                    stripped.clone()
-                } else {
-                    expression_tree::Expression::DebugHook {
-                        expression: Box::new(expr),
-                        id: property_id(counter, name),
-                    }
-                }
-            };
-        });
+    // We did not merge Elements yet and we have debug info!
+    assert_eq!(elem.debug.len(), 1);
+
+    // Ignore nodes previously set up
+    if elem.debug.first().expect("There was one element a moment ago").element_hash != 0 {
+        return;
     }
-    elem.debug.first_mut().expect("There was one element a moment ago").element_id = counter;
+
+    let element_hash = calculate_element_hash(&elem, random_state);
+
+    elem.bindings.iter().for_each(|(name, be)| {
+        let expr = std::mem::take(&mut be.borrow_mut().expression);
+        be.borrow_mut().expression = {
+            let stripped = super::ignore_debug_hooks(&expr);
+            if matches!(stripped, expression_tree::Expression::Invalid) {
+                stripped.clone()
+            } else {
+                expression_tree::Expression::DebugHook {
+                    expression: Box::new(expr),
+                    id: property_id(element_hash, name),
+                }
+            }
+        };
+    });
+
+    elem.debug.first_mut().expect("There was one element a moment ago").element_hash = element_hash;
 }

internal/compiler/passes/lower_layout.rs

@@ -60,7 +60,7 @@ pub fn lower_layouts(
 fn check_preferred_size_100(elem: &ElementRc, prop: &str, diag: &mut BuildDiagnostics) -> bool {
     let ret = if let Some(p) = elem.borrow().bindings.get(prop) {
         if p.borrow().expression.ty() == Type::Percent {
-            if !matches!(p.borrow().expression.ignore_debug_hook(), Expression::NumberLiteral(val, _) if val == 100.)
+            if !matches!(p.borrow().expression.ignore_debug_hooks(), Expression::NumberLiteral(val, _) if *val == 100.)
             {
                 diag.push_error(
                     format!("{prop} must either be a length, or the literal '100%'"),