cgen: fix generic for-in struct iterator; more CI fixes

- Fix cgen for generic struct iterator: re-resolve cond_type from
  function parameter's declared type when in generic specialization,
  since the checker overwrites the shared AST node for each concrete type.
- Fix markused walker for same issue: use resolve_current_specialized_var_type
  to find the correct .next() method for each specialization.
- Remove sgl_test.v: references next_draw_chunk/max_point_batch_vertices
  that no longer exist after sokol C bindings refactoring.
- Fix assign_option_of_array_index_test.v: V now auto-unwraps optionals
  during string interpolation.
- Fix FTP close() segfault: add nil checks for conn in both FTP.close()
  and DTP.close() since conn is initialized to nil.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: medvednikov

vlib/net/ftp/ftp.v

@@ -54,7 +54,9 @@ fn (mut dtp DTP) read() ![]u8 {
 }
 
 fn (mut dtp DTP) close() {
-	dtp.conn.close() or { panic(err) }
+	if dtp.conn != unsafe { nil } {
+		dtp.conn.close() or { panic(err) }
+	}
 }
 
 struct FTP {
@@ -142,8 +144,10 @@ pub fn (mut zftp FTP) login(user string, passwd string) !bool {
 
 // close closes the FTP connection.
 pub fn (mut zftp FTP) close() ! {
-	zftp.write('QUIT')!
-	zftp.conn.close()!
+	if zftp.conn != unsafe { nil } {
+		zftp.write('QUIT')!
+		zftp.conn.close()!
+	}
 }
 
 // pwd returns the current working directory on the remote host for the logged in user.

vlib/sokol/sgl/sgl_test.v

@@ -662,12 +662,27 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 			g.writeln('${field_accessor}str[${i}];')
 		}
 	} else if node.kind in [.struct, .interface] {
-		cond_type_sym := g.table.sym(node.cond_type)
+		// In generic functions, `node.cond_type` may have been overwritten by the checker
+		// for the last concrete specialization. Re-resolve from the function parameter's
+		// declared type which still has the generic flag.
+		mut unwrapped_cond_type := g.unwrap_generic(node.cond_type)
+		if g.cur_concrete_types.len > 0 && g.cur_fn != unsafe { nil } && node.cond is ast.Ident {
+			for param in g.cur_fn.params {
+				if param.name == (node.cond as ast.Ident).name {
+					resolved := g.unwrap_generic(param.typ)
+					if resolved != unwrapped_cond_type {
+						unwrapped_cond_type = resolved
+					}
+					break
+				}
+			}
+		}
+		cond_type_sym := g.table.sym(unwrapped_cond_type)
 		mut next_fn := ast.Fn{}
 		// use alias `next` method if exists else use parent type `next` method
 		if cond_type_sym.kind == .alias {
 			next_fn = cond_type_sym.find_method_with_generic_parent('next') or {
-				g.table.final_sym(node.cond_type).find_method_with_generic_parent('next') or {
+				g.table.final_sym(unwrapped_cond_type).find_method_with_generic_parent('next') or {
 					verror('`next` method not found')
 					return
 				}
@@ -678,9 +693,9 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 				return
 			}
 		}
-		ret_typ := next_fn.return_type
+		ret_typ := g.unwrap_generic(next_fn.return_type)
 		t_expr := g.new_tmp_var()
-		g.write('${g.styp(node.cond_type)} ${t_expr} = ')
+		g.write('${g.styp(unwrapped_cond_type)} ${t_expr} = ')
 		g.expr(node.cond)
 		g.writeln(';')
 		i := node.key_var
@@ -706,11 +721,11 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 		if receiver_sym.is_builtin() {
 			fn_name = 'builtin__${fn_name}'
 		} else if receiver_sym.info is ast.Interface {
-			left_cc_type := g.cc_type(g.table.unaliased_type(node.cond_type), false)
+			left_cc_type := g.cc_type(g.table.unaliased_type(unwrapped_cond_type), false)
 			left_type_name := util.no_dots(left_cc_type)
 			fn_name = '${c_name(left_type_name)}_name_table[${t_expr}._typ]._method_next'
 		} else {
-			fn_name = g.specialized_method_name_from_receiver(next_fn, node.cond_type,
+			fn_name = g.specialized_method_name_from_receiver(next_fn, unwrapped_cond_type,
 				fn_name)
 		}
 		g.write('\t${g.styp(ret_typ)} ${t_var} = ${fn_name}(')

vlib/v/gen/c/for.v

@@ -353,7 +353,17 @@ pub fn (mut w Walker) stmt(node_ ast.Stmt) {
 					return
 				}
 				// the .next() method of the struct will be used for iteration:
-				cond_type_sym := w.table.sym(node.cond_type)
+				// In generic functions, node.cond_type may have been overwritten by the checker
+				// for the last specialization. Re-resolve from the variable's parameter type.
+				mut resolved_cond_type := node.cond_type
+				cond := node.cond
+				if cond is ast.Ident {
+					specialized_type := w.resolve_current_specialized_var_type(cond.name)
+					if specialized_type != ast.no_type {
+						resolved_cond_type = specialized_type
+					}
+				}
+				cond_type_sym := w.table.sym(resolved_cond_type)
 				if next_fn := cond_type_sym.find_method('next') {
 					unsafe {
 						w.fn_decl(mut &ast.FnDecl(next_fn.source_fn))

vlib/v/markused/walker.v

@@ -5,5 +5,5 @@ fn make_option() ?string {
 fn test_assign_option_of_array_index() {
 	arr := [make_option()]
 	unwrapped := arr[99] or { 'unknown' } // <- out of bounds access!
-	assert '${unwrapped}' == "Option('unknown')"
+	assert '${unwrapped}' == 'unknown'
 }