pd-vm: debugger filtering of locals based on liveless and visibility

Author: fffonion

pd-vm/src/assembler.rs

@@ -77,9 +77,20 @@ impl Assembler {
         self.debug.add_function(name, args);
     }
 
-    pub fn add_local(&mut self, name: String, index: u8) {
-        self.debug.add_local(name, index);
-    }
+    pub fn add_local(&mut self, name: String, index: u8) {
+        self.debug.add_local(name, index);
+    }
+
+    pub fn add_local_with_range(
+        &mut self,
+        name: String,
+        index: u8,
+        declared_line: Option<u32>,
+        last_line: Option<u32>,
+    ) {
+        self.debug
+            .add_local_with_range(name, index, declared_line, last_line);
+    }
 
     pub fn add_constant(&mut self, value: Value) -> u32 {
         match value {

pd-vm/src/compiler/mod.rs

@@ -227,6 +227,12 @@ pub struct CompiledProgram {
     pub functions: Vec<FunctionDecl>,
 }
 
+#[derive(Clone, Copy, Debug, Default)]
+struct LocalDebugRange {
+    declared_line: Option<u32>,
+    last_line: Option<u32>,
+}
+
 impl CompiledProgram {
     #[cfg(feature = "runtime")]
     pub fn into_vm(self) -> Vm {
@@ -308,6 +314,7 @@ fn compile_parsed_output(
         .filter(|func| !is_compiler_primitive_import(&func.name))
         .cloned()
         .collect::<Vec<_>>();
+    let local_debug_ranges = collect_local_debug_ranges(&stmts, &function_impls);
 
     let mut compiler = Compiler::new();
     compiler.set_source(source);
@@ -317,8 +324,9 @@ fn compile_parsed_output(
         compiler.add_function_debug(func);
     }
     for (name, index) in local_bindings {
+        let range = local_debug_ranges.get(&index).copied().unwrap_or_default();
         compiler
-            .add_local_debug(name, index)
+            .add_local_debug(name, index, range.declared_line, range.last_line)
             .map_err(SourceError::Compile)?;
     }
     let mut program = compiler
@@ -469,8 +477,19 @@ impl Compiler {
             .add_function(func.name.clone(), func.args.clone());
     }
 
-    pub fn add_local_debug(&mut self, name: String, index: LocalSlot) -> Result<(), CompileError> {
-        self.assembler.add_local(name, local_slot_operand(index)?);
+    pub fn add_local_debug(
+        &mut self,
+        name: String,
+        index: LocalSlot,
+        declared_line: Option<u32>,
+        last_line: Option<u32>,
+    ) -> Result<(), CompileError> {
+        self.assembler.add_local_with_range(
+            name,
+            local_slot_operand(index)?,
+            declared_line,
+            last_line,
+        );
         Ok(())
     }
 
@@ -1066,6 +1085,212 @@ fn local_slot_operand(index: LocalSlot) -> Result<u8, CompileError> {
     u8::try_from(index).map_err(|_| CompileError::LocalSlotOverflow(index))
 }
 
+fn collect_local_debug_ranges(
+    stmts: &[Stmt],
+    function_impls: &HashMap<u16, FunctionImpl>,
+) -> HashMap<LocalSlot, LocalDebugRange> {
+    let mut ranges = HashMap::<LocalSlot, LocalDebugRange>::new();
+    for stmt in stmts {
+        record_stmt_local_debug_ranges(stmt, &mut ranges);
+    }
+    for function_impl in function_impls.values() {
+        for stmt in &function_impl.body_stmts {
+            record_stmt_local_debug_ranges(stmt, &mut ranges);
+        }
+        let fallback_line = function_impl
+            .body_stmts
+            .last()
+            .map(stmt_source_line)
+            .unwrap_or(1);
+        record_expr_local_debug_ranges(&function_impl.body_expr, fallback_line, &mut ranges);
+    }
+    ranges
+}
+
+fn record_stmt_local_debug_ranges(
+    stmt: &Stmt,
+    ranges: &mut HashMap<LocalSlot, LocalDebugRange>,
+) {
+    match stmt {
+        Stmt::Noop { .. } | Stmt::FuncDecl { .. } | Stmt::Break { .. } | Stmt::Continue { .. } => {}
+        Stmt::Let { index, expr, line } => {
+            note_local_decl(ranges, *index, *line);
+            record_expr_local_debug_ranges(expr, *line, ranges);
+        }
+        Stmt::Assign { index, expr, line } => {
+            note_local_use(ranges, *index, *line);
+            record_expr_local_debug_ranges(expr, *line, ranges);
+        }
+        Stmt::ClosureLet { line, closure } => {
+            for (source_slot, captured_slot) in &closure.capture_copies {
+                note_local_use(ranges, *source_slot, *line);
+                note_local_use(ranges, *captured_slot, *line);
+            }
+            record_expr_local_debug_ranges(&closure.body, *line, ranges);
+        }
+        Stmt::Expr { expr, line } => {
+            record_expr_local_debug_ranges(expr, *line, ranges);
+        }
+        Stmt::IfElse {
+            condition,
+            then_branch,
+            else_branch,
+            line,
+        } => {
+            record_expr_local_debug_ranges(condition, *line, ranges);
+            for nested in then_branch {
+                record_stmt_local_debug_ranges(nested, ranges);
+            }
+            for nested in else_branch {
+                record_stmt_local_debug_ranges(nested, ranges);
+            }
+        }
+        Stmt::For {
+            init,
+            condition,
+            post,
+            body,
+            line,
+        } => {
+            record_stmt_local_debug_ranges(init, ranges);
+            record_expr_local_debug_ranges(condition, *line, ranges);
+            record_stmt_local_debug_ranges(post, ranges);
+            for nested in body {
+                record_stmt_local_debug_ranges(nested, ranges);
+            }
+        }
+        Stmt::While {
+            condition,
+            body,
+            line,
+        } => {
+            record_expr_local_debug_ranges(condition, *line, ranges);
+            for nested in body {
+                record_stmt_local_debug_ranges(nested, ranges);
+            }
+        }
+    }
+}
+
+fn record_expr_local_debug_ranges(
+    expr: &Expr,
+    line: u32,
+    ranges: &mut HashMap<LocalSlot, LocalDebugRange>,
+) {
+    match expr {
+        Expr::Null
+        | Expr::Int(_)
+        | Expr::Float(_)
+        | Expr::Bool(_)
+        | Expr::String(_)
+        | Expr::FunctionRef(_) => {}
+        Expr::Var(index) => {
+            note_local_use(ranges, *index, line);
+        }
+        Expr::Call(_, args) => {
+            for arg in args {
+                record_expr_local_debug_ranges(arg, line, ranges);
+            }
+        }
+        Expr::LocalCall(index, args) => {
+            note_local_use(ranges, *index, line);
+            for arg in args {
+                record_expr_local_debug_ranges(arg, line, ranges);
+            }
+        }
+        Expr::Closure(closure) => {
+            for (source_slot, captured_slot) in &closure.capture_copies {
+                note_local_use(ranges, *source_slot, line);
+                note_local_use(ranges, *captured_slot, line);
+            }
+            record_expr_local_debug_ranges(&closure.body, line, ranges);
+        }
+        Expr::ClosureCall(closure, args) => {
+            for arg in args {
+                record_expr_local_debug_ranges(arg, line, ranges);
+            }
+            for (source_slot, captured_slot) in &closure.capture_copies {
+                note_local_use(ranges, *source_slot, line);
+                note_local_use(ranges, *captured_slot, line);
+            }
+            record_expr_local_debug_ranges(&closure.body, line, ranges);
+        }
+        Expr::Add(lhs, rhs)
+        | Expr::Sub(lhs, rhs)
+        | Expr::Mul(lhs, rhs)
+        | Expr::Div(lhs, rhs)
+        | Expr::Mod(lhs, rhs)
+        | Expr::And(lhs, rhs)
+        | Expr::Or(lhs, rhs)
+        | Expr::Eq(lhs, rhs)
+        | Expr::Lt(lhs, rhs)
+        | Expr::Gt(lhs, rhs) => {
+            record_expr_local_debug_ranges(lhs, line, ranges);
+            record_expr_local_debug_ranges(rhs, line, ranges);
+        }
+        Expr::Neg(inner) | Expr::Not(inner) => {
+            record_expr_local_debug_ranges(inner, line, ranges);
+        }
+        Expr::IfElse {
+            condition,
+            then_expr,
+            else_expr,
+        } => {
+            record_expr_local_debug_ranges(condition, line, ranges);
+            record_expr_local_debug_ranges(then_expr, line, ranges);
+            record_expr_local_debug_ranges(else_expr, line, ranges);
+        }
+        Expr::Match {
+            value_slot,
+            result_slot,
+            value,
+            arms,
+            default,
+        } => {
+            note_local_use(ranges, *value_slot, line);
+            note_local_use(ranges, *result_slot, line);
+            record_expr_local_debug_ranges(value, line, ranges);
+            for (_, arm_expr) in arms {
+                record_expr_local_debug_ranges(arm_expr, line, ranges);
+            }
+            record_expr_local_debug_ranges(default, line, ranges);
+        }
+        Expr::Block { stmts, expr } => {
+            for stmt in stmts {
+                record_stmt_local_debug_ranges(stmt, ranges);
+            }
+            record_expr_local_debug_ranges(expr, line, ranges);
+        }
+    }
+}
+
+fn note_local_decl(ranges: &mut HashMap<LocalSlot, LocalDebugRange>, slot: LocalSlot, line: u32) {
+    let entry = ranges.entry(slot).or_default();
+    entry.declared_line = Some(entry.declared_line.map_or(line, |current| current.min(line)));
+    entry.last_line = Some(entry.last_line.map_or(line, |current| current.max(line)));
+}
+
+fn note_local_use(ranges: &mut HashMap<LocalSlot, LocalDebugRange>, slot: LocalSlot, line: u32) {
+    let entry = ranges.entry(slot).or_default();
+    entry.last_line = Some(entry.last_line.map_or(line, |current| current.max(line)));
+}
+
+fn stmt_source_line(stmt: &Stmt) -> u32 {
+    match stmt {
+        Stmt::Noop { line }
+        | Stmt::Let { line, .. }
+        | Stmt::Assign { line, .. }
+        | Stmt::ClosureLet { line, .. }
+        | Stmt::FuncDecl { line, .. }
+        | Stmt::Expr { line, .. }
+        | Stmt::IfElse { line, .. }
+        | Stmt::For { line, .. }
+        | Stmt::While { line, .. }
+        | Stmt::Break { line }
+        | Stmt::Continue { line } => *line,
+    }
+}
+
 fn shift_amount_for_power_of_two(value: i64) -> Option<u32> {
     if value <= 0 {
         return None;

pd-vm/src/debug_info.rs

@@ -14,6 +14,8 @@ pub struct DebugFunction {
 pub struct LocalInfo {
     pub name: String,
     pub index: u8,
+    pub declared_line: Option<u32>,
+    pub last_line: Option<u32>,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq)]
@@ -106,14 +108,31 @@ impl DebugInfoBuilder {
     }
 
     pub fn add_local(&mut self, name: String, index: u8) {
-        if self
+        self.add_local_with_range(name, index, None, None);
+    }
+
+    pub fn add_local_with_range(
+        &mut self,
+        name: String,
+        index: u8,
+        declared_line: Option<u32>,
+        last_line: Option<u32>,
+    ) {
+        if let Some(existing) = self
             .locals
-            .iter()
-            .any(|local| local.name == name || local.index == index)
+            .iter_mut()
+            .find(|local| local.name == name || local.index == index)
         {
+            existing.declared_line = merge_min_line(existing.declared_line, declared_line);
+            existing.last_line = merge_max_line(existing.last_line, last_line);
             return;
         }
-        self.locals.push(LocalInfo { name, index });
+        self.locals.push(LocalInfo {
+            name,
+            index,
+            declared_line,
+            last_line,
+        });
     }
 
     pub fn mark_line(&mut self, offset: u32, line: u32) {
@@ -147,3 +166,21 @@ impl DebugInfoBuilder {
         })
     }
 }
+
+fn merge_min_line(current: Option<u32>, incoming: Option<u32>) -> Option<u32> {
+    match (current, incoming) {
+        (Some(lhs), Some(rhs)) => Some(lhs.min(rhs)),
+        (Some(lhs), None) => Some(lhs),
+        (None, Some(rhs)) => Some(rhs),
+        (None, None) => None,
+    }
+}
+
+fn merge_max_line(current: Option<u32>, incoming: Option<u32>) -> Option<u32> {
+    match (current, incoming) {
+        (Some(lhs), Some(rhs)) => Some(lhs.max(rhs)),
+        (Some(lhs), None) => Some(lhs),
+        (None, Some(rhs)) => Some(rhs),
+        (None, None) => None,
+    }
+}