Merge branch 'master' into davlgd-veb-static-gzip

* master:
  cgen: fix dump(ptr_to_fixed_array_value) - it now returns the argument directly (thanks @tankf33der) (vlang#25764)
  type_resolver: clear option flag if present in comptime $for (fix vlang#25761) (vlang#25763)
  db.sqlite: update windows version to https://sqlite.org/2025/sqlite-amalgamation-3510000.zip (vlang#25766)
  builder,pref: add  `-file-list` support (implement feature vlang#25707) (vlang#25749)
  transformer: transform ArrayInit into a function call for C and native backends (part 1)
  doc: cleanup grammar issues in doc/docs.md
  parser: allow using `a`, `b` and `it` as var names, when using the builtin array methods (fix vlang#25729) (vlang#25755)
  v.builder: improve diagnostic information for a failed build_thirdparty_obj_file
  veb: fix gzip middleware decode/encode (fix vlang#20865) (fix vlang#25753) (vlang#25754)
  strconv: fix handling of subnormal numbers like `'1.23e-308'.f64()` (fix vlang#25751) (vlang#25752)
  crypto.blake2b,crypto.blake2s: add `@[direct_array_access]` to hot functions (vlang#25750)

Author: spytheman

.github/workflows/windows-install-sqlite.bat

@@ -1,11 +1,11 @@
 @echo off
 
-curl -L https://www.sqlite.org/2024/sqlite-amalgamation-3450300.zip -o sqlite-amalgamation-3450300.zip
+curl -L https://sqlite.org/2025/sqlite-amalgamation-3510000.zip -o sqlite-amalgamation-3510000.zip
 
-unzip sqlite-amalgamation-3450300.zip -d thirdparty\
+unzip sqlite-amalgamation-3510000.zip -d thirdparty\
 
-del thirdparty\sqlite-amalgamation-3450300\shell.c
+del thirdparty\sqlite-amalgamation-3510000\shell.c
 
-move /y thirdparty\sqlite-amalgamation-3450300 thirdparty\sqlite
+move /y thirdparty\sqlite-amalgamation-3510000 thirdparty\sqlite
 
 dir thirdparty\sqlite

doc/docs.md

@@ -921,16 +921,16 @@ f2 := 456e+2 // 45600
 
 An array is a collection of data elements of the same type. An array literal is a
 list of expressions surrounded by square brackets. An individual element can be
-accessed using an *index* expression. Indexes start from `0`:
+accessed using an *index* expression. Indexing starts from `0`.
 
 ```v
-mut nums := [1, 2, 3]
-println(nums) // `[1, 2, 3]`
-println(nums[0]) // `1`
-println(nums[1]) // `2`
+mut nums := [10, 20, 30]
+println(nums) // `[10, 20, 30]`
+println(nums[0]) // `10`
+println(nums[1]) // `20`
 
 nums[1] = 5
-println(nums) // `[1, 5, 3]`
+println(nums) // `[10, 5, 30]`
 ```
 
 <a id='array-operations'></a>
@@ -4214,8 +4214,8 @@ fn pass_time(w World) {
 
 ### Option/Result types and error handling
 
-Option types are for types which may represent `none`. Result types may
-represent an error returned from a function.
+Option types can represent a value or `none`. Result types may
+represent a value, or an error returned from a function.
 
 `Option` types are declared by prepending `?` to the type name: `?Type`.
 `Result` types use `!`: `!Type`.
@@ -4467,9 +4467,9 @@ post := posts_repo.find_by_id(1)? // find_by_id[Post]
 ```
 
 Currently generic function definitions must declare their type parameters, but in
-future V will infer generic type parameters from single-letter type names in
-runtime parameter types. This is why `find_by_id` can omit `[T]`, because the
-receiver argument `r` uses a generic type `T`.
+future versions, V will infer generic type parameters from single-letter type names in
+runtime parameter types. This is why the `find_by_id(1)` calls above can omit `[T]`,
+because the receiver argument `r` in the method declaration, uses a generic type `T`.
 
 Another example:
 
@@ -5135,10 +5135,11 @@ Remaining small percentage of objects is freed via GC. The developer doesn't nee
 anything in their code. "It just works", like in Python, Go, or Java, except there's no
 heavy GC tracing everything or expensive RC for each object.
 
-For developers willing to have more low level control, memory can be managed manually with
+For developers willing to have more low-level control, memory can be managed manually with
 `-gc none`.
 
-Arena allocation is available via v `-prealloc`.
+Arena allocation is available via a `-prealloc` flag. Note: currently this mode is only
+suitable to speed up short lived, single-threaded, batch-like programs (like compilers).
 
 ### Control
 
@@ -5159,7 +5160,7 @@ Just as the compiler frees C data types with C's `free()`, it will statically in
 
 Autofree can be enabled with an `-autofree` flag.
 
-For developers willing to have more low level control, autofree can be disabled with
+For developers willing to have more low-level control, autofree can be disabled with
 `-manualfree`, or by adding a `[manualfree]` on each function that wants to manage its
 memory manually. (See [attributes](#attributes)).
 
@@ -5232,7 +5233,7 @@ be stored:
 
 #### V's default approach
 
-Due to performance considerations V tries to put objects on the stack if possible
+Due to performance considerations V tries to put objects on the stack if possible,
 but allocates them on the heap when obviously necessary. Example:
 
 ```v
@@ -7410,7 +7411,7 @@ rm pgo_gen
 
 ## Atomics
 
-V has no special support for atomics, yet, nevertheless it's possible to treat variables as atomics
+V has no special support for atomics yet, nevertheless it's possible to treat variables as atomics
 by [calling C](#v-and-c) functions from V. The standard C11 atomic functions like `atomic_store()`
 are usually defined with the help of macros and C compiler magic to provide a kind of
 *overloaded C functions*.
@@ -7499,7 +7500,7 @@ will hang &ndash; dependent on the compiler optimization used.)
 
 ## Global Variables
 
-By default V does not allow global variables. However, in low level applications they have their
+By default V does not allow global variables. However, in low-level applications they have their
 place so their usage can be enabled with the compiler flag `-enable-globals`.
 Declarations of global variables must be surrounded with a `__global ( ... )`
 specification &ndash; as in the example [above](#atomics).
@@ -7550,7 +7551,7 @@ namespaced globals).
 
 Note: their use is discouraged too, for reasons similar to why globals
 are discouraged. The feature is supported to enable translating existing
-low level C code into V code, using `v translate`.
+low-level C code into V code, using `v translate`.
 
 Note: the function in which you use a static variable, has to be marked
 with @[unsafe]. Also unlike using globals, using static variables, do not
@@ -7603,7 +7604,7 @@ v -os freebsd .
 > Cross-compiling a Windows binary on a Linux machine requires the GNU C compiler for
 > MinGW-w64 (targeting Win64) to first be installed.
 
-For Ubuntu/Debian based distributions:
+For Ubuntu/Debian-based distributions:
 
 ```shell
 sudo apt install gcc-mingw-w64-x86-64
@@ -7632,7 +7633,7 @@ To debug issues in the generated binary (flag: `-b c`), you can pass these flags
 - `-g` - produces a less optimized executable with more debug information in it.
   V will enforce line numbers from the .v files in the stacktraces, that the
   executable will produce on panic. It is usually better to pass -g, unless
-  you are writing low level code, in which case use the next option `-cg`.
+  you are writing low-level code, in which case use the next option `-cg`.
 - `-cg` - produces a less optimized executable with more debug information in it.
   The executable will use C source line numbers in this case. It is frequently
   used in combination with `-keepc`, so that you can inspect the generated
@@ -7645,7 +7646,7 @@ To debug issues in the generated binary (flag: `-b c`), you can pass these flags
   compilation. Also keep using the same file path, so it is more stable,
   and easier to keep opened in an editor/IDE.
 
-For best debugging experience if you are writing a low level wrapper for an existing
+For best debugging experience if you are writing a low-level wrapper for an existing
 C library, you can pass several of these flags at the same time:
 `v -keepc -cg -showcc yourprogram.v`, then just run your debugger (gdb/lldb) or IDE
 on the produced executable `yourprogram`.

vlib/crypto/blake2b/blake2b_block_generic.v

@@ -11,7 +11,7 @@ module blake2b
 import math.bits
 
 // mixing function g
-@[inline]
+@[direct_array_access; inline]
 fn g(mut v []u64, a u8, b u8, c u8, d u8, x u64, y u64) {
 	v[a] = v[a] + v[b] + x
 	v[d] = bits.rotate_left_64((v[d] ^ v[a]), nr1)
@@ -24,7 +24,7 @@ fn g(mut v []u64, a u8, b u8, c u8, d u8, x u64, y u64) {
 }
 
 // one complete mixing round with the function g
-@[inline]
+@[direct_array_access; inline]
 fn (d Digest) mixing_round(mut v []u64, s []u8) {
 	g(mut v, 0, 4, 8, 12, d.m[s[0]], d.m[s[1]])
 	g(mut v, 1, 5, 9, 13, d.m[s[2]], d.m[s[3]])
@@ -38,6 +38,7 @@ fn (d Digest) mixing_round(mut v []u64, s []u8) {
 }
 
 // compression function f
+@[direct_array_access]
 fn (mut d Digest) f(f bool) {
 	// initialize the working vector
 	mut v := []u64{len: 0, cap: 16}

vlib/crypto/blake2s/blake2s_block_generic.v

@@ -11,7 +11,7 @@ module blake2s
 import math.bits
 
 // mixing function g
-@[inline]
+@[direct_array_access; inline]
 fn g(mut v []u32, a u8, b u8, c u8, d u8, x u32, y u32) {
 	v[a] = v[a] + v[b] + x
 	v[d] = bits.rotate_left_32((v[d] ^ v[a]), nr1)
@@ -24,7 +24,7 @@ fn g(mut v []u32, a u8, b u8, c u8, d u8, x u32, y u32) {
 }
 
 // one complete mixing round with the function g
-@[inline]
+@[direct_array_access; inline]
 fn (d Digest) mixing_round(mut v []u32, s []u8) {
 	g(mut v, 0, 4, 8, 12, d.m[s[0]], d.m[s[1]])
 	g(mut v, 1, 5, 9, 13, d.m[s[2]], d.m[s[3]])
@@ -38,6 +38,7 @@ fn (d Digest) mixing_round(mut v []u32, s []u8) {
 }
 
 // compression function f
+@[direct_array_access]
 fn (mut d Digest) f(f bool) {
 	// initialize the working vector
 	mut v := []u32{len: 0, cap: 16}

vlib/strconv/atof.c.v

@@ -298,6 +298,30 @@ fn converter(mut pn PrepNumber) u64 {
 			s0 = q0
 		}
 	}
+
+	// Handle subnormal (denormalized) numbers - very small numbers near zero
+	//
+	// Normal floats have an implicit leading 1 bit in their mantissa (like 1.xxxxx).
+	// When numbers get too small (binexp < -1022), we can't represent them normally.
+	// Instead, we use subnormals: set exponent to 0 and shift the mantissa right,
+	// losing precision gradually. This prevents abrupt underflow to zero.
+	//
+	// Example: 1.23e-308 is smaller than the minimum normal float, so we:
+	// 1. Keep the normalized mantissa from s2 and s1
+	// 2. Shift it right to "denormalize" it (the leading 1 moves into the mantissa)
+	// 3. Round correctly using the bits that were shifted out
+	// 4. Return with exponent = 0 (subnormal marker)
+	if binexp < -1022 && (s2 | s1) != 0 {
+		shift := -1022 - binexp
+		if shift > 60 {
+			return if pn.negative { double_minus_zero } else { double_plus_zero }
+		}
+		shifted := ((u64(s2) << 32) | u64(s1)) >> u32(shift)
+		q := (shifted >> 8) +
+			u64((shifted >> 7) & 1 != 0 && ((shifted & 0x7F) != 0 || (shifted >> 8) & 1 != 0))
+		return (q & 0x000FFFFFFFFFFFFF) | (u64(pn.negative) << 63)
+	}
+
 	// rounding if needed
 	/*
 	* "round half to even" algorithm
@@ -374,6 +398,8 @@ fn converter(mut pn PrepNumber) u64 {
 			result = double_plus_infinity
 		}
 	} else if binexp < 1 {
+		// Should not reach here for subnormals anymore (handled earlier)
+		// This is now only for true zeros
 		if pn.negative {
 			result = double_minus_zero
 		} else {

vlib/strconv/atof_test.c.v

@@ -82,6 +82,29 @@ fn test_atof() {
 	println('DONE!')
 }
 
+fn test_atof_subnormal() {
+	// Test subnormal (denormalized) float numbers and edge cases
+	// These are very small numbers close to the f64 minimum
+	// IMPORTANT: Compare with hardcoded f64 literals, not .f64() which uses the same parser
+
+	// Normal numbers
+	assert strconv.atof64('1.0e-250') or { panic('parse error') } == 1.0e-250
+	assert strconv.atof64('2.5e-260') or { panic('parse error') } == 2.5e-260
+
+	// Transition zone
+	assert strconv.atof64('1.0e-300') or { panic('parse error') } == 1.0e-300
+	assert strconv.atof64('2.2250738585072014e-308') or { panic('parse error') } == 2.2250738585072014e-308
+
+	// Subnormal numbers (these fail without the fix)
+	assert strconv.atof64('1.23e-308') or { panic('parse error') } == 1.23e-308
+	assert strconv.atof64('1.0e-310') or { panic('parse error') } == 1.0e-310
+	assert strconv.atof64('5.0e-320') or { panic('parse error') } == 5.0e-320
+	assert strconv.atof64('5e-324') or { panic('parse error') } == 5e-324
+
+	// Negative subnormal
+	assert strconv.atof64('-1.0e-320') or { panic('parse error') } == -1.0e-320
+}
+
 fn test_atof_errors() {
 	if x := strconv.atof64('') {
 		eprintln('> x: ${x}')

vlib/v/ast/table.v

@@ -2837,3 +2837,8 @@ pub fn (mut t Table) get_veb_result_type_idx() int {
 pub fn (mut t Table) register_vls_info(key string, val VlsInfo) {
 	t.vls_info[key] = val
 }
+
+pub fn (t &Table) unwrap(typ Type) Type {
+	ts := t.sym(typ)
+	return if ts.info is Alias { t.unwrap(ts.info.parent_type) } else { typ }
+}

vlib/v/builder/builder_test.v

@@ -43,3 +43,42 @@ fn test_conditional_executable_removal() {
 	dump(after_second_run___)
 	assert executable in after_second_run___
 }
+
+fn test_file_list() {
+	os.chdir(test_path)!
+	os.mkdir_all('filelist')!
+	os.write_file('filelist/main.v', 'module main
+fn main() {
+        part_a := AS{}
+        part_b := BS{}
+        println("\${part_a}=>\${part_b}")
+}')!
+	os.write_file('filelist/part_a.v', 'module main
+pub struct AS{}
+')!
+
+	os.write_file('filelist/part_b.v', 'module main
+pub struct BS{}
+')!
+
+	// `part_c.v` is not included in the compilation
+	// or there will be a conflit definition of `struct BS`
+	os.write_file('filelist/part_c.v', 'module main
+pub struct BS{}
+')!
+	mut executable := 'filelist_check'
+	$if windows {
+		executable += '.exe'
+	}
+
+	original_file_list_ := os.ls(test_path)!
+	dump(original_file_list_)
+	assert executable !in original_file_list_
+
+	cmd := '${os.quoted_path(vexe)} -o ${executable} filelist/main.v -file-list "filelist/part_a.v,filelist/part_b.v,"'
+	os.execute(cmd)
+	after_compile_file_list := os.ls(test_path)!.filter(os.exists(it))
+	dump(after_compile_file_list)
+	assert executable in after_compile_file_list
+	assert os.execute('./${executable}').output.trim_space() == 'AS{}=>BS{}'
+}

vlib/v/builder/cc.v

@@ -1248,7 +1248,13 @@ fn (mut v Builder) build_thirdparty_obj_file(mod string, path string, moduleflag
 	res := os.execute(cmd)
 	os.chdir(current_folder) or {}
 	if res.exit_code != 0 {
-		eprintln('failed thirdparty object build cmd:\n${cmd}')
+		eprintln('> Failed build_thirdparty_obj_file cmd')
+		eprintln('>           mod: ${mod}')
+		eprintln('>          path: ${path}')
+		eprintln('>         cfile: ${cfile}')
+		eprintln('> wd before cmd: ${current_folder}')
+		eprintln('> getwd for cmd: ${v.pref.vroot}')
+		eprintln('>           cmd: ${cmd}')
 		verror(res.output)
 		return
 	}

vlib/v/builder/compile.v

@@ -369,6 +369,24 @@ pub fn (v &Builder) get_user_files() []string {
 		user_files << single_test_v_file
 		dir = os.dir(single_test_v_file)
 	}
+	v.add_file_or_dir(mut user_files, dir)
+	for f in v.pref.file_list {
+		file := f.trim_space()
+		if file.len > 0 {
+			v.add_file_or_dir(mut user_files, file)
+		}
+	}
+	if user_files.len == 0 {
+		println('No input .v files')
+		exit(1)
+	}
+	if v.pref.is_verbose {
+		v.log('user_files: ${user_files}')
+	}
+	return user_files
+}
+
+fn (v &Builder) add_file_or_dir(mut user_files []string, dir string) {
 	does_exist := os.exists(dir)
 	if !does_exist {
 		verror("${dir} doesn't exist")
@@ -381,7 +399,7 @@ pub fn (v &Builder) get_user_files() []string {
 		// Just compile one file and get parent dir
 		user_files << single_v_file
 		if v.pref.is_verbose {
-			v.log('> just compile one file: "${single_v_file}"')
+			v.log('> add one file: "${single_v_file}"')
 		}
 	} else if os.is_dir(dir) {
 		if v.pref.is_verbose {
@@ -395,12 +413,4 @@ pub fn (v &Builder) get_user_files() []string {
 		println('unknown file extension `${ext}`')
 		exit(1)
 	}
-	if user_files.len == 0 {
-		println('No input .v files')
-		exit(1)
-	}
-	if v.pref.is_verbose {
-		v.log('user_files: ${user_files}')
-	}
-	return user_files
 }