Merge remote-tracking branch 'upstream/master' into codex/fix-26759-implicit-cast

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: vincenzopalazzo

doc/docs.md

@@ -5639,13 +5639,40 @@ instead:
 - Fedora/RHEL: `sudo dnf -y install sqlite-devel`
 - Arch: `sudo pacman -S sqlite`
 
+### Interactive SQLite CLI
+
+V includes a built-in SQLite CLI (`v sqlite`) as a V-native
+replacement for `sqlite3`:
+
+```sh
+v sqlite mydb.db
+```
+
+It provides a full readline REPL with history and tab completion,
+9 output modes, `.dump`, `.import`/`.export`, `.backup`, session
+control, and schema tools. Run `.help` inside the REPL for the
+full command list.
+
+### Convenience Methods
+
+The `db.sqlite` module includes helper methods for common queries:
+
+```v ignore
+db.tables()!         // list all user table names
+db.columns('users')! // column names for a table
+db.schema('users')!  // CREATE statement(s)
+db.db_size()!        // file size in bytes
+```
+
 ### Using the self contained SQLite module
-V also maintains a separate `sqlite` module, that wraps an SQLite amalgamation, but otherwise
-has the same API as the `db.sqlite` module. Its benefit, is that with it, you do not need to
-install a separate system level sqlite package/library on your system (which can be hard on
-some systems like windows, or systems with musl for example).
-Its negative is that it can make your compilations a bit slower (since it compiles SQLite
-from C, in addition to your own code).
+
+V also maintains a separate `sqlite` module, that wraps an SQLite
+amalgamation, but otherwise has the same API as the `db.sqlite`
+module. Its benefit is that you do not need to install a separate
+system-level sqlite package (which can be hard on some systems
+like Windows, or systems with musl for example). Its downside is
+that it can make compilations a bit slower since it compiles
+SQLite from C in addition to your own code.
 
 To use it, do:
 ```sh

vlib/db/sqlite/README.md

@@ -21,6 +21,43 @@ instead:
 - Fedora/RHEL: `sudo dnf -y install sqlite-devel`
 - Arch: `sudo pacman -S sqlite`
 
+# Convenience Methods
+
+The `DB` struct provides several helper methods for common
+introspection queries:
+
+```v
+import db.sqlite
+
+db := sqlite.connect('mydb.db') or { panic(err) }
+
+// List all user tables
+tables := db.tables()!
+
+// Get column names for a table
+cols := db.columns('users')!
+
+// Get CREATE statements (single table or all objects)
+s := db.schema('users')!
+
+// Database file size in bytes
+size := db.db_size()!
+```
+
+# Interactive CLI
+
+V includes a built-in SQLite CLI as a replacement for `sqlite3`:
+
+```sh
+v sqlite mydb.db
+```
+
+Features include a full readline REPL with history and tab
+completion, 9 output modes (`table`, `box`, `markdown`, `csv`,
+`json`, `line`, `html`, `insert`, `quote`), `.dump`,
+`.import`/`.export`, `.backup`, session control, and schema tools.
+Run `.help` inside the REPL for the full command list.
+
 # Performance Tips
 
 When performing a large amount of database calls (i.e. INSERTS), significant

vlib/db/sqlite/sqlite.c.v

@@ -582,6 +582,43 @@ pub fn (mut db DB) release_savepoint(savepoint string) ! {
 	db.exec('RELEASE SAVEPOINT ${savepoint};')!
 }
 
+// tables returns the names of all user tables in the database.
+pub fn (db &DB) tables() ![]string {
+	rows := db.exec("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name")!
+	return rows.map(it.vals[0])
+}
+
+// columns returns the column names for the given table.
+pub fn (db &DB) columns(table string) ![]string {
+	escaped := table.replace('"', '""')
+	rows := db.exec('PRAGMA table_info("${escaped}")')!
+	return rows.map(it.vals[1])
+}
+
+// schema returns the CREATE statement(s) for the given table, or for all
+// objects if table is empty.
+pub fn (db &DB) schema(table string) !string {
+	filter := if table != '' {
+		escaped := table.replace("'", "''")
+		"AND name='${escaped}'"
+	} else {
+		''
+	}
+	rows := db.exec("SELECT sql FROM sqlite_master WHERE type IN ('table','index','view','trigger') ${filter} AND sql IS NOT NULL ORDER BY type, name")!
+	return rows.map(it.vals[0]).join('\n\n')
+}
+
+// db_size returns the database file size in bytes, computed from page_count
+// and page_size.
+pub fn (db &DB) db_size() !i64 {
+	pc := db.exec('PRAGMA page_count')!
+	ps := db.exec('PRAGMA page_size')!
+	if pc.len == 0 || ps.len == 0 {
+		return 0
+	}
+	return pc[0].vals[0].i64() * ps[0].vals[0].i64()
+}
+
 // reset returns the connection to initial state for reuse
 pub fn (mut db DB) reset() ! {
 }

vlib/db/sqlite/sqlite_test.v

@@ -1,6 +1,7 @@
 // vtest build: present_sqlite3?
 import db.sqlite
 import orm
+import os
 
 type Connection = sqlite.DB
 
@@ -148,6 +149,46 @@ fn test_exec_param_many2() {
 	db.close()!
 }
 
+fn test_tables() {
+	mut db := sqlite.connect(':memory:') or { panic(err) }
+	db.exec('create table alpha (id integer)')!
+	db.exec('create table beta (id integer)')!
+	tbl := db.tables()!
+	assert tbl == ['alpha', 'beta']
+	db.close()!
+}
+
+fn test_columns() {
+	mut db := sqlite.connect(':memory:') or { panic(err) }
+	db.exec('create table items (id integer primary key, name text, price real)')!
+	cols := db.columns('items')!
+	assert cols == ['id', 'name', 'price']
+	db.close()!
+}
+
+fn test_schema() {
+	mut db := sqlite.connect(':memory:') or { panic(err) }
+	db.exec('create table things (id integer primary key, label text)')!
+	s := db.schema('things')!
+	assert s.contains('CREATE TABLE things')
+	// empty table name returns all objects
+	all := db.schema('')!
+	assert all.contains('CREATE TABLE things')
+	db.close()!
+}
+
+fn test_db_size() {
+	tmp := os.join_path(os.temp_dir(), 'test_db_size.db')
+	defer {
+		os.rm(tmp) or {}
+	}
+	mut db := sqlite.connect(tmp) or { panic(err) }
+	db.exec('create table t (id integer)')!
+	sz := db.db_size()!
+	assert sz > 0
+	db.close()!
+}
+
 fn test_orm_transaction_interface() {
 	mut db := sqlite.connect(':memory:') or { panic(err) }
 	defer {

vlib/v/gen/c/fn.v

@@ -2878,8 +2878,8 @@ fn (mut g Gen) call_args(node ast.CallExpr) {
 						}
 					}
 				} else {
-					// passing variadic arg to another call which expects same array type
-					if variadic_count == 1
+					// passing the current variadic arg to another call which expects the same array type
+					if variadic_count == 1 && g.is_forwarded_variadic_arg(args[arg_nr])
 						&& ((args[arg_nr].typ.has_flag(.variadic) && args[arg_nr].typ == varg_type)
 						|| (varg_type.has_flag(.variadic)
 						&& args[arg_nr].typ == varg_type.clear_flag(.variadic)
@@ -2919,6 +2919,18 @@ fn (mut g Gen) call_args(node ast.CallExpr) {
 	}
 }
 
+fn (g &Gen) is_forwarded_variadic_arg(arg ast.CallArg) bool {
+	if arg.typ.has_flag(.variadic) {
+		return true
+	}
+	if arg.expr is ast.Ident && g.cur_fn != unsafe { nil } && g.cur_fn.is_variadic
+		&& g.cur_fn.params.len > 0 && arg.expr.obj is ast.Var {
+		var_obj := arg.expr.obj as ast.Var
+		return var_obj.is_arg && arg.expr.name == g.cur_fn.params.last().name
+	}
+	return false
+}
+
 // similar to `autofree_call_pregen()` but only to to handle [keep_args_alive] for C functions
 fn (mut g Gen) keep_alive_call_pregen(node ast.CallExpr) int {
 	g.empty_line = true

vlib/v/tests/fns/variadic_interface_array_arg_test.v

@@ -0,0 +1,24 @@
+interface VariadicValue {}
+
+fn variadic_capture(values ...VariadicValue) []VariadicValue {
+	return values
+}
+
+fn test_variadic_interface_array_variable_as_single_arg() {
+	nested := [VariadicValue('brother')]
+	got := variadic_capture(nested)
+	assert got.len == 1
+
+	inner := got[0] as []VariadicValue
+	assert inner.len == 1
+	assert (inner[0] as string) == 'brother'
+}
+
+fn test_variadic_interface_array_literal_as_single_arg() {
+	got := variadic_capture([VariadicValue('x')])
+	assert got.len == 1
+
+	inner := got[0] as []VariadicValue
+	assert inner.len == 1
+	assert (inner[0] as string) == 'x'
+}

vlib/v/tests/typeof_test.v

@@ -120,17 +120,21 @@ fn test_typeof_on_sumtypes_of_structs() {
 	assert d.type_name() == 'UnaryExpr'
 }
 
-fn raw_sumtype_typeof(v ExprType) string {
-	return typeof(v)
-}
-
 fn test_raw_typeof_on_sumtypes_is_printable() {
 	a := fexpr(1)
 	b := fexpr(2)
 	c := fexpr(3)
-	assert raw_sumtype_typeof(a) == 'UnaryExpr'
-	assert raw_sumtype_typeof(b) == 'BinExpr'
-	assert raw_sumtype_typeof(c) == 'BoolExpr'
+	raw_a_type := typeof(a)
+	raw_b_type := typeof(b)
+	raw_c_type := typeof(c)
+	// Regresses issue #26704: raw typeof(sumtype) should be usable
+	// when returned from a helper and printable via the stored result.
+	println(raw_a_type)
+	println(raw_b_type)
+	println(raw_c_type)
+	assert raw_a_type == 'UnaryExpr'
+	assert raw_b_type == 'BinExpr'
+	assert raw_c_type == 'BoolExpr'
 }
 
 fn myfn(i int) int {