builtin: show file and line number in backtraces; v2: implements, clone() auto generation

Author: medvednikov

cmd/v/v.v

@@ -207,22 +207,22 @@ fn invoke_help_and_exit(remaining []string) {
 }
 
 fn maybe_delegate_to_v2(command string, prefs &pref.Preferences) {
-	if !prefs.use_v2 {
+	is_ownership := '-ownership' in os.args
+	if !prefs.use_v2 && !is_ownership {
 		return
 	}
 	if !is_v2_relevant_command(command, prefs) {
-		eprintln('v: `-v2` currently supports direct compilation only. Use `v -v2 hello.v` or `v -v2 -b arm64 hello.v`.')
+		eprintln('v: `-v2`/`-ownership` currently support direct compilation only. Use `v -v2 hello.v` or `v -ownership module_dir`.')
 		exit(1)
 	}
-	is_ownership := '-ownership' in os.args
 	launch_v2_compiler(prefs.is_verbose, os.args[1..].filter(it != '-v2'), is_ownership)
 }
 
 fn is_v2_relevant_command(command string, prefs &pref.Preferences) bool {
 	if prefs.path == '' || prefs.is_run || prefs.is_crun {
 		return false
 	}
-	return command.ends_with('.v') && prefs.path.ends_with('.v')
+	return prefs.path == command && (command.ends_with('.v') || os.exists(command))
 }
 
 @[noreturn]

vlib/builtin/backtraces.c.v

@@ -23,6 +23,87 @@ pub fn print_backtrace() {
 	}
 }
 
+// demangle_v_symbol converts a C-mangled V symbol name to a human-readable V name.
+// For example: `veb__run_T_main__App_main__Context` => `veb.run[main.App, main.Context]`
+@[direct_array_access]
+fn demangle_v_symbol(cname string) string {
+	mut name := cname
+	// Strip builtin__ prefix:
+	if name.starts_with('builtin__') {
+		name = name[9..]
+	}
+	// Replace pointer type encoding:
+	name = name.replace('__ptr__', '&')
+	// Split base name from generic parameters on `_T_`:
+	// C mangling: `base_T_type1_type2` where each type is prefixed with `_`
+	// and types may contain `__` for module separators.
+	t_pos := name.index('_T_') or { -1 }
+	if t_pos >= 0 {
+		base := name[..t_pos].replace('__', '.')
+		generic_suffix := name[t_pos + 3..]
+		// Split on single `_` that is not part of `__` (double underscore).
+		params := split_generic_params(generic_suffix)
+		mut demangled_params := []string{cap: params.len}
+		for param in params {
+			demangled_params << param.replace('__', '.')
+		}
+		return base + '[' + demangled_params.join(', ') + ']'
+	}
+	// No generics - just replace module separator:
+	name = name.replace('__', '.')
+	// `main.main` is V's internal C mangling, in V it's just `main`:
+	if name == 'main.main' {
+		return 'main'
+	}
+	return name
+}
+
+// split_generic_params splits a generic suffix like `main__App_main__Context`
+// into individual type parameters [`main__App`, `main__Context`].
+// Splits on single `_` but not `__` (double underscore used for module separators).
+@[direct_array_access]
+fn split_generic_params(s string) []string {
+	mut params := []string{}
+	mut start := 0
+	mut i := 0
+	for i < s.len {
+		if s[i] == `_` {
+			if i + 1 < s.len && s[i + 1] == `_` {
+				// Part of `__` (module separator), skip both.
+				i += 2
+			} else {
+				// Single `_` is a generic param separator.
+				if i > start {
+					params << s[start..i]
+				}
+				i++
+				start = i
+			}
+		} else {
+			i++
+		}
+	}
+	if start < s.len {
+		params << s[start..]
+	}
+	return params
+}
+
+// demangle_backtrace_sym demangles a V symbol within a Linux-style backtrace fragment.
+// Linux format: `./executable(symbol_name+0x1a4) `
+fn demangle_backtrace_sym(s string) string {
+	paren_start := s.index('(') or { return s }
+	plus_pos := s.index_after_('+', paren_start)
+	if plus_pos < 0 {
+		return s
+	}
+	symbol := s[paren_start + 1..plus_pos]
+	if symbol.len == 0 {
+		return s
+	}
+	return s[..paren_start + 1] + demangle_v_symbol(symbol) + s[plus_pos..]
+}
+
 fn eprint_space_padding(output string, max_len int) {
 	padding_len := max_len - output.len
 	if padding_len > 0 {

vlib/builtin/backtraces_nix.c.v

@@ -31,12 +31,110 @@ fn print_backtrace_skipping_top_frames_bsd(skipframes int) bool {
 				eprintln('C.backtrace returned less than 2 frames')
 				return false
 			}
-			C.backtrace_symbols_fd(&buffer[skipframes], nr_ptrs - skipframes, 2)
+			nr_actual_frames := nr_ptrs - skipframes
+			csymbols := C.backtrace_symbols(voidptr(&buffer[skipframes]), nr_actual_frames)
+			atos_lines := bsd_backtrace_resolve_atos(&buffer[skipframes], nr_actual_frames)
+			for i in 0 .. nr_actual_frames {
+				sframe := unsafe { tos2(&u8(csymbols[i])) }
+				mut file_line := ''
+				if i < atos_lines.len {
+					file_line = atos_lines[i]
+				}
+				// macOS format: `0   main   0x00000001047232f8 veb__run_T_main__App_main__Context + 356`
+				symbol_start := sframe.index('0x') or { -1 }
+				if symbol_start < 0 {
+					continue
+				}
+				rest := sframe[symbol_start..]
+				space_after_addr := rest.index(' ') or { -1 }
+				if space_after_addr < 0 {
+					continue
+				}
+				symbol_and_offset := rest[space_after_addr + 1..]
+				plus_pos := symbol_and_offset.index(' + ') or { -1 }
+				mut raw_symbol := symbol_and_offset
+				if plus_pos >= 0 {
+					raw_symbol = symbol_and_offset[..plus_pos]
+				}
+				// Skip C runtime frames that are not V functions:
+				if raw_symbol in ['main', 'start', '_main'] {
+					continue
+				}
+				mut demangled := ''
+				if plus_pos >= 0 {
+					demangled = demangle_v_symbol(raw_symbol) + symbol_and_offset[plus_pos..]
+				} else {
+					demangled = demangle_v_symbol(raw_symbol)
+				}
+				if file_line.len > 0 {
+					eprint(file_line)
+					eprint_space_padding(file_line, 45)
+					eprint(' | ')
+					eprintln(demangled)
+				} else {
+					eprintln(demangled)
+				}
+			}
+			if nr_actual_frames > 0 {
+				unsafe { C.free(csymbols) }
+			}
 		}
 		return true
 	}
 }
 
+// bsd_backtrace_resolve_atos uses macOS `atos` to resolve addresses to file:line info.
+// Returns an array of file:line strings (one per frame). Empty string if unresolved.
+@[direct_array_access]
+fn bsd_backtrace_resolve_atos(buffer &voidptr, nr_frames int) []string {
+	$if macos {
+		exe_name := backtrace_current_executable_name()
+		if exe_name.len == 0 {
+			return []string{}
+		}
+		base_addr := C._dyld_get_image_header(0)
+		if base_addr == unsafe { nil } {
+			return []string{}
+		}
+		// Build single atos command with all addresses for efficiency:
+		mut cmd := 'atos --fullPath -o "' + exe_name + '" -l ' + ptr_str(base_addr)
+		for i in 0 .. nr_frames {
+			cmd += ' ' + ptr_str(unsafe { buffer[i] })
+		}
+		f := C.popen(&char(cmd.str), c'r')
+		if f == unsafe { nil } {
+			return []string{}
+		}
+		buf := [4096]u8{}
+		mut lines := []string{cap: nr_frames}
+		unsafe {
+			bp := &buf[0]
+			for C.fgets(&char(bp), 4096, f) != 0 {
+				line := tos(bp, vstrlen(bp)).trim_chars(' \t\n\r', .trim_both)
+				// atos output format: `func_name (in binary) (file.v:42)`
+				// Extract the last parenthesized (file:line) part:
+				paren_pos := line.index_last_('(')
+				if paren_pos >= 0 {
+					file_part := line[paren_pos + 1..]
+					end_paren := file_part.index_last_(')')
+					if end_paren >= 0 {
+						file_line := file_part[..end_paren]
+						if file_line.contains(':') && !file_line.starts_with('in ')
+							&& !file_line.contains('.tmp.c:') {
+							lines << file_line
+							continue
+						}
+					}
+				}
+				lines << ''
+			}
+		}
+		C.pclose(f)
+		return lines
+	}
+	return []string{}
+}
+
 fn C.tcc_backtrace(fmt &char) i32
 
 fn backtrace_current_executable_name() string {
@@ -132,7 +230,7 @@ fn print_backtrace_skipping_top_frames_linux(skipframes int) bool {
 						eprint(' | ')
 						eprint(addr)
 						eprint(' | ')
-						eprintln(beforeaddr)
+						eprintln(demangle_backtrace_sym(beforeaddr))
 					}
 					if nr_actual_frames > 0 {
 						unsafe { C.free(csymbols) }

vlib/builtin/backtraces_windows.c.v

@@ -122,7 +122,7 @@ fn print_backtrace_skipping_top_frames_msvc(skipframes int) bool {
 					// addr:
 					lineinfo = '?? : address = 0x' + ptr_str(frame_addr)
 				}
-				sfunc := unsafe { tos3(fname) }
+				sfunc := demangle_v_symbol(unsafe { tos3(fname) })
 				snframe := i64(nframe).str()
 				eprint_space_padding(snframe, 2)
 				eprint(': ')

vlib/builtin/builtin_backtraces_nix.c.v

@@ -4,3 +4,9 @@ module builtin
 fn C.backtrace(a &voidptr, size i32) i32
 fn C.backtrace_symbols(a &voidptr, size i32) &&char
 fn C.backtrace_symbols_fd(a &voidptr, size i32, fd i32)
+
+$if macos {
+	#include <mach-o/dyld.h>
+
+	fn C._dyld_get_image_header(image_index u32) voidptr
+}

vlib/builtin/builtin_d_use_libbacktrace.c.v

@@ -47,7 +47,7 @@ fn bt_print_callback(data &BacktraceOptions, pc voidptr, filename_ptr &char, lin
 	fn_name := if fn_name_ptr == unsafe { nil } {
 		'???'
 	} else {
-		(unsafe { fn_name_ptr.vstring() }).replace('__', '.')
+		demangle_v_symbol(unsafe { fn_name_ptr.vstring() })
 	}
 	// keep it for later
 	// pc_64 := u64(pc)

vlib/builtin/string_d_ownership.v

@@ -3,6 +3,12 @@
 // Provides .to_owned() which creates an owned string with move semantics.
 module builtin
 
+// IClone marks values that provide explicit clone semantics in ownership mode.
+//
+// This is a marker interface. Concrete types still define their own `clone()`
+// methods with concrete return types.
+pub interface IClone {}
+
 // to_owned creates an owned copy of the string.
 // When ownership checking is enabled, owned strings have move semantics:
 // assigning an owned string to another variable moves ownership,

vlib/v/gen/c/fn.v

@@ -3384,8 +3384,8 @@ fn (mut g Gen) unwrap_receiver_type(node ast.CallExpr) (ast.Type, &ast.TypeSymbo
 	mut typ_sym := g.table.sym(unwrapped_rec_type)
 	mut left_sym := g.table.sym(left_type)
 	if left_type != 0 && left_type != g.unwrap_generic(node.receiver_type)
-		&& left_sym.kind != .aggregate
-		&& left_sym.has_method(node.name) && node.from_embed_types.len == 0 {
+		&& left_sym.kind != .aggregate && left_sym.has_method(node.name)
+		&& node.from_embed_types.len == 0 {
 		unwrapped_rec_type = left_type
 		typ_sym = left_sym
 	}
@@ -3522,8 +3522,7 @@ fn (mut g Gen) method_call(node ast.CallExpr) {
 	if left_type != 0 && (left_type != g.unwrap_generic(node.receiver_type)
 		|| left_type != unwrapped_rec_type) {
 		resolved_left_sym := g.table.sym(left_type)
-		if resolved_left_sym.kind != .aggregate
-			&& (resolved_left_sym.has_method(method_name)
+		if resolved_left_sym.kind != .aggregate && (resolved_left_sym.has_method(method_name)
 			|| resolved_left_sym.has_method_with_generic_parent(method_name)) {
 			unwrapped_rec_type = left_type
 			receiver_type = left_type.derive(node.receiver_type).clear_flag(.generic)

vlib/v2/ast/ast.v

@@ -925,6 +925,7 @@ pub:
 	attributes     []Attribute
 	is_public      bool
 	is_union       bool
+	implements     []Expr
 	embedded       []Expr
 	language       Language = .v
 	name           string

vlib/v2/ast_dump/ast_dump.v

@@ -655,6 +655,11 @@ fn (mut jb JsonBuilder) write_interface_decl(stmt ast.InterfaceDecl) {
 	jb.write_exprs(stmt.generic_params)
 	jb.sb.write_string(',\n')
 
+	jb.write_indent()
+	jb.sb.write_string('"implements": ')
+	jb.write_exprs(stmt.implements)
+	jb.sb.write_string(',\n')
+
 	jb.write_indent()
 	jb.sb.write_string('"embedded": ')
 	jb.write_exprs(stmt.embedded)