v2: integrate v2.types into ssa; string structs

Author: medvednikov

cmd/v2/test.v

@@ -2210,5 +2210,29 @@ fn main() {
 	// 44.5 Comptime in function call
 	print_int(get_comptime_value())
 
+	// ==================== 45. STRING STRUCT FIELDS ====================
+	print_str('--- 45. String Struct Fields ---')
+
+	// 45.1 String literal .str field
+	s45_1 := 'Hello'
+	print_str(s45_1) // Hello
+
+	// 45.2 String literal .len field
+	s45_2 := 'World'
+	print_int(s45_2.len) // 5
+
+	// 45.3 Interpolated string .len field
+	val45 := 123
+	s45_3 := 'Val: ${val45}'
+	print_int(s45_3.len) // 8
+
+	// 45.4 Multiple string operations
+	a45 := 'AB'
+	b45 := 'CDE'
+	print_int(a45.len + b45.len) // 5
+
+	// 45.5 String in function parameter
+	print_str('Passed directly') // Passed directly
+
 	print_str('=== All tests completed ===')
 }

vlib/v2/gen/arm64/arm64.v

@@ -24,6 +24,9 @@ pub mut:
 	reg_map   map[int]int
 	used_regs []int
 	next_blk  int
+
+	// Track which string literals have been materialized (value_id -> str_data offset)
+	string_literal_offsets map[int]int
 }
 
 pub fn Gen.new(mod &ssa.Module) &Gen {
@@ -84,6 +87,7 @@ fn (mut g Gen) gen_func(func ssa.Function) {
 	g.pending_labels = map[int][]int{}
 	g.reg_map = map[int]int{}
 	g.used_regs = []int{}
+	g.string_literal_offsets = map[int]int{}
 	g.allocate_registers(func)
 
 	// Stack Frame
@@ -94,6 +98,16 @@ fn (mut g Gen) gen_func(func ssa.Function) {
 		slot_offset += 8
 	}
 
+	// Pre-pass: allocate stack slots for string_literal values
+	for val in g.mod.values {
+		if val.kind == .string_literal {
+			// String struct needs 24 bytes (str ptr + len + is_lit)
+			slot_offset = (slot_offset + 15) & ~0xF
+			slot_offset += 24
+			g.stack_map[val.id] = -slot_offset
+		}
+	}
+
 	for i, blk_id in func.blocks {
 		g.next_blk = if i + 1 < func.blocks.len { func.blocks[i + 1] } else { -1 }
 		blk := g.mod.blocks[blk_id]
@@ -133,6 +147,14 @@ fn (mut g Gen) gen_func(func ssa.Function) {
 				slot_offset += 8
 			}
 
+			if instr.op == .inline_string_init {
+				// String struct needs 24 bytes (str ptr + len + is_lit)
+				slot_offset = (slot_offset + 15) & ~0xF
+				slot_offset += 24
+				g.stack_map[val_id] = -slot_offset
+				continue // Don't allocate another 8 bytes below
+			}
+
 			if val_id in g.reg_map {
 				continue
 			}
@@ -593,6 +615,34 @@ fn (mut g Gen) gen_instr(val_id int) {
 			// This is used after code that should never be reached (e.g., after exit() in assert)
 			g.emit(0x00000000)
 		}
+		.inline_string_init {
+			// Create string struct by value: { str, len, is_lit }
+			// operands: [str_ptr, len, is_lit]
+			// This instruction creates a string struct on the stack
+			// The result is a pointer to the struct
+			str_ptr_id := instr.operands[0]
+			len_id := instr.operands[1]
+			is_lit_id := instr.operands[2]
+
+			// Get base pointer for this value's stack slot
+			base_offset := g.stack_map[val_id]
+
+			// Store str field (offset 0)
+			g.load_val_to_reg(8, str_ptr_id)
+			g.emit_str_reg_offset(8, 29, base_offset)
+
+			// Store len field (offset 8)
+			g.load_val_to_reg(9, len_id)
+			g.emit_str_reg_offset(9, 29, base_offset + 8)
+
+			// Store is_lit field (offset 16)
+			g.load_val_to_reg(10, is_lit_id)
+			g.emit_str_reg_offset(10, 29, base_offset + 16)
+
+			// Return pointer to struct (base address)
+			g.emit_add_fp_imm(8, base_offset) // x8 = fp + offset
+			g.store_reg_to_val(8, val_id)
+		}
 		else {
 			eprintln('arm64: unknown instruction ${instr}')
 			exit(1)
@@ -659,6 +709,50 @@ fn (mut g Gen) load_val_to_reg(reg int, val_id int) {
 		g.emit(0x90000000 | u32(reg))
 		g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_pageoff12, false)
 		g.emit(0x91000000 | u32(reg) | (u32(reg) << 5))
+	} else if val.kind == .string_literal {
+		// String literal: create string struct { str, len, is_lit } on stack
+		// val.name contains the string content, val.index contains the length
+
+		// Get stack slot for this string struct (24 bytes: str ptr + len + is_lit)
+		base_offset := g.stack_map[val_id]
+
+		// Check if we've already materialized this string literal
+		if _ := g.string_literal_offsets[val_id] {
+			// Already materialized - just load pointer to the struct
+			g.emit_add_fp_imm(reg, base_offset)
+		} else {
+			// First time - create string data and initialize struct
+			str_content := val.name
+			str_len := val.index
+
+			// Create the string data in cstring section
+			str_offset2 := g.macho.str_data.len
+			g.macho.str_data << str_content.bytes()
+			g.macho.str_data << 0 // null terminator
+
+			// Track that we've materialized this string literal
+			g.string_literal_offsets[val_id] = str_offset2
+
+			// Store str pointer (offset 0): load address of string data
+			sym_idx := g.macho.add_symbol('L_str_${str_offset2}', u64(str_offset2), false,
+				2)
+			g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_page21, true)
+			g.emit(0x90000000 | u32(reg))
+			g.macho.add_reloc(g.macho.text_data.len, sym_idx, arm64_reloc_pageoff12, false)
+			g.emit(0x91000000 | u32(reg) | (u32(reg) << 5))
+			g.emit_str_reg_offset(reg, 29, base_offset)
+
+			// Store len (offset 8)
+			g.emit_mov_imm64(9, str_len)
+			g.emit_str_reg_offset(9, 29, base_offset + 8)
+
+			// Store is_lit = 1 (offset 16)
+			g.emit_mov_imm64(10, 1)
+			g.emit_str_reg_offset(10, 29, base_offset + 16)
+
+			// Load pointer to string struct into reg
+			g.emit_add_fp_imm(reg, base_offset)
+		}
 	} else {
 		// Handles .instruction, .argument, etc.
 		if reg_idx := g.reg_map[val_id] {

vlib/v2/gen/c/c.v

@@ -26,6 +26,11 @@ pub fn (mut g Gen) gen() string {
 	g.sb.writeln('#include <stdbool.h>')
 	g.sb.writeln('#include <stddef.h>')
 	g.sb.writeln('#include <stdio.h>')
+	g.sb.writeln('#include <stdlib.h>')
+	g.sb.writeln('#include <string.h>')
+	g.sb.writeln('')
+	// Builtin string type
+	g.sb.writeln('typedef struct { int8_t* str; int64_t len; int64_t is_lit; } string;')
 	g.sb.writeln('')
 
 	g.gen_struct_decls()
@@ -58,24 +63,47 @@ fn (mut g Gen) gen_func_decls() {
 fn (mut g Gen) gen_struct_decls() {
 	for i, t in g.mod.type_store.types {
 		if t.kind == .struct_t {
+			// Skip builtin string type (already defined)
+			if g.is_string_type(i) {
+				continue
+			}
 			g.sb.writeln('typedef struct Struct_${i} Struct_${i};')
 		}
 	}
 	g.sb.writeln('')
 
 	for i, t in g.mod.type_store.types {
 		if t.kind == .struct_t {
+			// Skip builtin string type (already defined)
+			if g.is_string_type(i) {
+				continue
+			}
 			g.sb.writeln('struct Struct_${i} {')
 			for idx, field_id in t.fields {
 				type_name := g.type_name(field_id)
-				g.sb.writeln('\t${type_name} field_${idx};')
+				// Use named fields if available
+				field_name := if idx < t.field_names.len {
+					t.field_names[idx]
+				} else {
+					'field_${idx}'
+				}
+				g.sb.writeln('\t${type_name} ${field_name};')
 			}
 			g.sb.writeln('};')
 		}
 	}
 	g.sb.writeln('')
 }
 
+fn (g Gen) is_string_type(type_id int) bool {
+	t := g.mod.type_store.types[type_id]
+	if t.kind == .struct_t && t.field_names.len == 3 {
+		return t.field_names[0] == 'str' && t.field_names[1] == 'len'
+			&& t.field_names[2] == 'is_lit'
+	}
+	return false
+}
+
 fn (mut g Gen) gen_globals() {
 	for gvar in g.mod.globals {
 		tname := g.type_name(gvar.typ)
@@ -265,11 +293,18 @@ fn (mut g Gen) gen_instr(val_id int) {
 			elem_type := g.mod.type_store.types[elem_type_id]
 
 			if elem_type.kind == .struct_t {
+				// Get field name - use named field if available, otherwise fall back to field_N
+				idx := idx_val.name.int()
+				field_name := if idx < elem_type.field_names.len {
+					elem_type.field_names[idx]
+				} else {
+					'field_${idx_val.name}'
+				}
 				// For globals, the C declaration is not a pointer, so use '.' instead of '->'
 				if base_val.kind == .global {
-					g.sb.writeln('\t${res} = &${base}.field_${idx_val.name};')
+					g.sb.writeln('\t${res} = &${base}.${field_name};')
 				} else {
-					g.sb.writeln('\t${res} = &${base}->field_${idx_val.name};')
+					g.sb.writeln('\t${res} = &${base}->${field_name};')
 				}
 			} else {
 				idx := g.val_str(instr.operands[1])
@@ -308,6 +343,13 @@ fn (mut g Gen) gen_instr(val_id int) {
 			// Unreachable code - typically after abort/exit
 			g.sb.writeln('\t__builtin_unreachable();')
 		}
+		.inline_string_init {
+			// Create string struct by value: (string){str, len, is_lit}
+			str_ptr := g.val_str(instr.operands[0])
+			len_val := g.val_str(instr.operands[1])
+			is_lit := g.val_str(instr.operands[2])
+			g.sb.writeln('\t${res} = (string){(int8_t*)${str_ptr}, ${len_val}, ${is_lit}};')
+		}
 		else {
 			g.sb.writeln('\t// Unhandled C op: ${instr.op}')
 		}
@@ -333,12 +375,20 @@ fn (g Gen) type_name(id int) string {
 			if elem_t.kind == .array_t {
 				return g.type_name(elem_t.elem_type) + '*'
 			}
+			// Check if pointing to string struct
+			if g.is_string_type(t.elem_type) {
+				return 'string*'
+			}
 			return g.type_name(t.elem_type) + '*'
 		}
 		.array_t {
 			return g.type_name(t.elem_type) + '*'
 		} // Arrays decay to pointers
 		.struct_t {
+			// Check for builtin string type
+			if g.is_string_type(id) {
+				return 'string'
+			}
 			return 'Struct_${id}'
 		}
 		else {
@@ -355,6 +405,10 @@ fn (g Gen) val_str(id int) string {
 		return val.name
 	} else if val.kind == .global {
 		return val.name
+	} else if val.kind == .string_literal {
+		// String literal: generate inline struct literal
+		// val.name contains the string content, val.index contains length
+		return '(string){"${val.name}", ${val.index}, 1}'
 	}
 	return '_v${val.id}'
 }