all: fix more tests

Author: medvednikov

vlib/os/os_windows.c.v

@@ -119,9 +119,12 @@ fn wide_ptr_to_string(wstr &u16) string {
 }
 
 fn looks_like_utf16le_captured_output(raw string) bool {
-	if raw.len < 2 || raw.len % 2 != 0 {
+	if raw.len < 2 {
 		return false
 	}
+	// Allow odd-length buffers: Windows text-mode translation can insert
+	// extra bytes (e.g. \r before \n), producing odd-length UTF-16LE output.
+	// In that case, just ignore the trailing byte during detection.
 	if raw[0] == 0xff && raw[1] == 0xfe {
 		return true
 	}
@@ -189,7 +192,32 @@ fn decode_windows_captured_output(raw string) string {
 		return utf16_captured_output_to_string(raw, false)
 	}
 	if validate.utf8_string(raw) {
-		return raw
+		// Check for embedded null bytes, which suggest this is actually UTF-16
+		// that wasn't detected (e.g. due to text-mode \r\n translation corrupting
+		// the byte alignment). Strip null bytes as a recovery heuristic.
+		mut has_null := false
+		for i in 0 .. raw.len {
+			if raw[i] == 0 {
+				has_null = true
+				break
+			}
+		}
+		if !has_null {
+			return raw
+		}
+		// Contains null bytes — likely corrupted UTF-16LE.
+		// Strip null bytes and normalize \r\n to \n (text-mode artifacts).
+		mut cleaned := strings.new_builder(raw.len)
+		for i in 0 .. raw.len {
+			if raw[i] == 0 {
+				continue
+			}
+			if raw[i] == 0x0D && i + 1 < raw.len && raw[i + 1] == 0x0A {
+				continue
+			}
+			cleaned.write_u8(raw[i])
+		}
+		return cleaned.str()
 	}
 	mut wide := raw.to_wide(from_ansi: true)
 	if isnil(wide) {

vlib/v/ast/comptime_valid_idents.v

@@ -89,10 +89,11 @@ pub fn eval_comptime_not_user_defined_ident(ident string, the_pref &pref.Prefere
 				is_true = !the_pref.m64
 			}
 			'little_endian' {
-				is_true = $if little_endian { true } $else { false }
+				// ppc64le is little-endian (the 'le' suffix), all others below are big-endian
+				is_true = the_pref.arch !in [.ppc64, .ppc, .sparc64, .s390x]
 			}
 			'big_endian' {
-				is_true = $if big_endian { true } $else { false }
+				is_true = the_pref.arch in [.ppc64, .ppc, .sparc64, .s390x]
 			}
 			else {
 				return error('invalid \$if condition: unknown cpu_features `${ident}`')

vlib/v/ast/table.v

@@ -1132,6 +1132,16 @@ fn (mut t Table) rewrite_already_registered_symbol(typ TypeSymbol, existing_idx
 		}
 		return existing_idx
 	}
+	// Allow C type aliases to override existing C types (e.g. `type C.WCHAR = u16`
+	// on Windows where WCHAR is already registered from system headers):
+	if typ.kind == .alias && typ.language == .c && existing_symbol.language == .c {
+		t.type_symbols[existing_idx] = &TypeSymbol{
+			...typ
+			idx:        existing_idx
+			is_builtin: existing_symbol.is_builtin
+		}
+		return existing_idx
+	}
 	// Override the already registered builtin types with the actual
 	// v struct declarations in the vlib/builtin module sources:
 	if (existing_idx >= string_type_idx && existing_idx <= map_type_idx)

vlib/v/gen/c/auto_free_methods.v

@@ -118,7 +118,12 @@ fn (mut g Gen) gen_free_for_interface(sym ast.TypeSymbol, info ast.Interface, st
 			continue
 		}
 		type_styp := g.gen_type_name_for_free_call(typ_)
-		fn_builder.writeln('\tif (it->_typ == _${sym.cname}_${sub_sym.cname}_index) { ${type_styp}_free(it->_${sub_sym.cname}); return; }')
+		free_fn_name := if sub_sym.is_builtin() {
+			'builtin__${type_styp}_free'
+		} else {
+			'${type_styp}_free'
+		}
+		fn_builder.writeln('\tif (it->_typ == _${sym.cname}_${sub_sym.cname}_index) { ${free_fn_name}(it->_${sub_sym.cname}); return; }')
 	}
 	fn_builder.writeln('}')
 }

vlib/v/gen/c/cgen.v

@@ -7892,7 +7892,8 @@ fn (mut g Gen) cast_expr(node ast.CastExpr) {
 			&& sym.info.parent_type !in [expr_type, ast.string_type]) {
 			if sym.kind == .string && !node_typ.is_ptr() {
 				cast_label = '*(string*)&'
-			} else if !((g.is_cc_msvc && g.styp(node_typ) == g.styp(expr_type))
+			} else if !((g.is_cc_msvc && (g.styp(node_typ) == g.styp(expr_type)
+				|| g.styp(g.table.unaliased_type(node_typ)) == g.styp(g.table.unaliased_type(expr_type))))
 				|| (final_sym.kind == .array_fixed && final_expr_sym == final_sym)) {
 				// not cast fixed array, which will use `memcpy`
 				cast_label = '(${styp})'

vlib/v/parser/parser.v

@@ -2276,7 +2276,8 @@ fn (mut p Parser) dot_expr(left ast.Expr) ast.Expr {
 	} else {
 		p.name_error = true
 	}
-	if ast.builtin_array_generic_methods_matcher.matches(field_name) {
+	if ast.builtin_array_generic_methods_matcher.matches(field_name) && (p.tok.kind == .lpar
+		|| is_generic_call || (p.tok.kind == .not && p.peek_tok.kind == .lpar)) {
 		if p.file_backend_mode == .v || p.file_backend_mode == .c {
 			p.register_auto_import('builtin.closure')
 		}