How to get a strack trace when an error is thrown?

[caramboleyo]

Everything seems empty.

use boa_engine::{Context, Source, js_string};
use boa_runtime::Console;

fn main() {
    println!("=== Independent Boa JavaScript Demo ===\n");
    
    let mut context = Context::default();
    let console = Console::init(&mut context);
    context.register_global_property(Console::NAME, console, boa_engine::property::Attribute::all())
        .expect("Failed to register console");
    
    let code = r#"
const a = 0;
iWillCauseAnError
const b = a + 1;
console.log(b);
"#;
    
    // Try with a Source that has a path
    let source = Source::from_reader(code.as_bytes(), Some(std::path::Path::new("test.js")));
    
    match context.eval(source) {
        Ok(_) => println!("\n✓ Script executed successfully"),
        Err(e) => {
            eprintln!("\n✗ Error Display: {}", e);
            eprintln!("\n✗ Error Debug: {:#?}", e);
            
            eprintln!("\n=== Converting to opaque JsValue ===");
            let opaque = e.to_opaque(&mut context);
            eprintln!("Opaque: {:?}", opaque);
            
            // Try to get error properties
            if let Some(obj) = opaque.as_object() {
                eprintln!("\n=== Error Object Properties ===");
                if let Ok(msg) = obj.get(js_string!("message"), &mut context) {
                    eprintln!("message: {:?}", msg);
                }
                if let Ok(stack) = obj.get(js_string!("stack"), &mut context) {
                    eprintln!("stack: {:?}", stack);
                }
                if let Ok(line) = obj.get(js_string!("lineNumber"), &mut context) {
                    eprintln!("lineNumber: {:?}", line);
                }
                if let Ok(col) = obj.get(js_string!("columnNumber"), &mut context) {
                    eprintln!("columnNumber: {:?}", col);
                }
                if let Ok(file) = obj.get(js_string!("fileName"), &mut context) {
                    eprintln!("fileName: {:?}", file);
                }
            }
            
            eprintln!("\n=== Stack from Context ===");
            for (i, frame) in context.stack_trace().enumerate() {
                let name = frame.code_block().name();
                eprintln!("Frame {}: {}", i, name.to_std_string_escaped());
                eprintln!("  Full frame: {:#?}", frame);
            }
        }
    }
}

do i have to keep track of the files myself or can i somehow set path of a module so the error contains it?

[caramboleyo]

Okay, what Claude did:

1. tossed the crates.io version
2. git cloned this repo using main
3. installed rust nightly
4. changed code using frame.position:

            eprintln!("\n=== Stack from Context ===");
            for (i, frame) in context.stack_trace().enumerate() {
                let location = frame.position();
                eprintln!("Frame {}: {}", i, location.function_name.to_std_string_escaped());
                eprintln!("  Path: {}", location.path);
                eprintln!("  Position: {:?}", location.position);
                if let Some(pos) = location.position {
                    eprintln!("  Line: {}, Column: {}", pos.line_number(), pos.column_number());
                }
            }

i have now partial stacktraces, but sometimes there are no frames so i cant call position() - this seems to be related to promise resolving or async code. I dont know if i am just too stupid or if this is a bug in boa :/

[nekevss]

Hi!

Stack traces are actually not currently supported on the last released version of Boa (0.20).

That being said, stack traces have been implemented in the upcoming release of Boa (0.21), which we are in the works of putting together. So, the availability of stack traces will essentially rely on whether you are using 0.20 or the git repository.

[jedel1043]

FWIW, we currently only allow printing stack traces, but we haven't exposed the API for inspecting them. This will probably be part of the 1.0 API review process

[caramboleyo]

Claude already fixed boa/core/engine/src/error.rs 377
problem is simply that backtrace is lost at
Repr::Native(e) => e.to_opaque(context).into(),

this is his fix in case it saves you some time someday:

    pub fn to_opaque(&self, context: &mut Context) -> JsValue {
        match &self.inner {
            Repr::Native(e) => {
                let obj = e.to_opaque(context);
                
                // Set stack property from backtrace if available
                if let Some(backtrace) = &self.backtrace {
                    use crate::vm::shadow_stack::ShadowEntry;
                    
                    let mut stack_str = e.message.to_string();
                    
                    for entry in backtrace.iter() {
                        stack_str.push_str("\n    at ");
                        
                        // Extract function name and location
                        match entry {
                            ShadowEntry::Native { function_name, .. } => {
                                if let Some(name) = function_name {
                                    stack_str.push_str(&name.to_std_string_escaped());
                                } else {
                                    stack_str.push_str("<anonymous>");
                                }
                                let location = format!("{}", entry);
                                if !location.is_empty() {
                                    stack_str.push_str(&location);
                                }
                            }
                            ShadowEntry::Bytecode { source_info, .. } => {
                                let func_name = source_info.function_name().to_std_string_escaped();
                                if !func_name.is_empty() && func_name != "<main>" {
                                    stack_str.push_str(&func_name);
                                    stack_str.push(' ');
                                }
                                let location = format!("{}", entry);
                                stack_str.push_str(&location);
                            }
                        }
                    }
                    
                    obj.create_non_enumerable_data_property_or_throw(
                        js_string!("stack"),
                        js_string!(stack_str),
                        context,
                    );
                    
                    // Set lineNumber, columnNumber, and fileName from the first bytecode entry
                    for entry in backtrace.iter() {
                        if let ShadowEntry::Bytecode { pc, source_info } = entry {
                            let path = source_info.map().path();
                            let position = source_info.map().find(*pc);
                            
                            if let Some(pos) = position {
                                obj.create_non_enumerable_data_property_or_throw(
                                    js_string!("lineNumber"),
                                    JsValue::from(pos.line_number()),
                                    context,
                                );
                                obj.create_non_enumerable_data_property_or_throw(
                                    js_string!("columnNumber"),
                                    JsValue::from(pos.column_number()),
                                    context,
                                );
                            }
                            
                            let path_str = format!("{}", path);
                            if !path_str.is_empty() {
                                obj.create_non_enumerable_data_property_or_throw(
                                    js_string!("fileName"),
                                    js_string!(path_str),
                                    context,
                                );
                            }
                            
                            break; // Only use the first bytecode entry
                        }
                    }
                }
                
                obj.into()
            },
            Repr::Opaque(v) => v.clone(),
        }
    }

[caramboleyo]

Ah okay, i see i forgot to describe what happenend in the meantime: i use modules only and we (think we) found out that when using context.eval(source) you get a proper error with file, line number and col. But i use modules everywhere (Module::parse(source, None, &mut context)) and there those infos are missing in the error. According to Claude because backtrace is lost at error.rs as mentioned above. Claude hacked in what i needed and now i see a similar stacktrace to when executed with Script. Maybe thats a bug?

[jedel1043]

Oh yeah, indeed it seems like a bug. I would be wary about using your solution though, because it stores everything as JS properties, so you could lose your stack trace by just overriding the used properties.

Can you open an issue about this? We should be able to fix this by adding additional context to the Error object or something