v3: keep @[aligned] struct alignment under MSVC

The MSVC preamble defines `__attribute__` away, which also dropped the
`__attribute__((aligned(N)))` suffix of `@[aligned]` structs. For MSVC,
emit `__declspec(align (N))` between the tag and the name instead (16 for
a bare `@[aligned]`, GCC's meaning on x86-64 and arm64), as in
testdata/aligned_attr_msvc_windows.c.must_have. Map `__alignof__`, used
for heap copies of such structs, to MSVC's `__alignof`.

Author: medvednikov

vlib/v/gen/c/cleanc.v

@@ -18154,6 +18154,8 @@ fn (mut g FlatGen) preamble() {
 	g.writeln('#define _Thread_local __declspec(thread)')
 	g.writeln('#endif')
 	g.writeln('#define _Atomic volatile')
+	// Heap copies of `@[aligned]` structs ask for their alignment with GCC's spelling.
+	g.writeln('#define __alignof__(x) __alignof(x)')
 	g.writeln('#endif')
 	if use_system_libc {
 		g.writeln('typedef ptrdiff_t isize;')

vlib/v/gen/c/names_test.v

@@ -202,6 +202,43 @@ fn test_target_libc_opaque_packed_struct_restores_packing() {
 	assert c_code.contains('#pragma pack(push, 1)\nstruct TargetOpaque;\n#pragma pack(pop)')
 }
 
+fn aligned_struct_decl_c(ccompiler string, attrs string, union_decl bool) string {
+	mut a := flat.FlatAst.new()
+	mut tc := types.TypeChecker.new(&a)
+	name := 'Aligned'
+	tc.structs[name] = []types.StructField{}
+	if union_decl {
+		tc.unions[name] = true
+	}
+	node_id := a.add_node(flat.Node{
+		kind:  .struct_decl
+		value: name
+		typ:   attrs
+	})
+	mut g := FlatGen.new()
+	g.a = &a
+	g.tc = &tc
+	g.set_ccompiler(ccompiler)
+	g.register_struct_decl_info_at(int(node_id), name, name, 'main', '/project/main.v', a.nodes[int(node_id)])
+	g.emit_struct(name)
+	return g.sb.str()
+}
+
+fn test_aligned_struct_decls_use_the_msvc_alignment_spelling() {
+	msvc := aligned_struct_decl_c('msvc', 'aligned=8', false)
+	assert msvc.contains('struct __declspec(align (8)) Aligned {'), msvc
+	assert !msvc.contains('__attribute__'), msvc
+	msvc_union := aligned_struct_decl_c('msvc', 'aligned=16', true)
+	assert msvc_union.contains('union __declspec(align (16)) Aligned {'), msvc_union
+	// A bare `@[aligned]` means the target's largest alignment, as with GCC.
+	msvc_bare := aligned_struct_decl_c('msvc', 'aligned', false)
+	assert msvc_bare.contains('struct __declspec(align (16)) Aligned {'), msvc_bare
+	gcc := aligned_struct_decl_c('gcc', 'aligned=8', false)
+	assert gcc.contains('struct Aligned {'), gcc
+	assert gcc.contains('} __attribute__((aligned(8)));'), gcc
+	assert !gcc.contains('__declspec'), gcc
+}
+
 fn test_collect_cache_native_c_symbols_only_records_type_declarations() {
 	mut a := flat.FlatAst.new()
 	mut tc := types.TypeChecker.new(&a)

vlib/v/gen/c/struct.v

@@ -4500,6 +4500,14 @@ fn struct_decl_alignment_attr(align StructDeclAlignment) string {
 	return '__attribute__((aligned(${align.value})))'
 }
 
+// struct_decl_alignment_declspec is MSVC's spelling of a struct alignment. A bare
+// `@[aligned]` asks for the target's largest alignment, like GCC's `aligned`, which is
+// 16 bytes on the x86-64 and arm64 targets MSVC compiles for.
+fn struct_decl_alignment_declspec(align StructDeclAlignment) string {
+	value := if align.value.len > 0 { align.value } else { '16' }
+	return '__declspec(align (${value}))'
+}
+
 fn struct_decl_alignment_memdup_arg(align StructDeclAlignment, c_type string) string {
 	if align.value.len > 0 {
 		return align.value
@@ -6406,14 +6414,27 @@ fn (mut g FlatGen) emit_struct(name string) {
 			g.tc.cur_module = old_module
 			return
 		}
-		g.writeln('${g.struct_decl_head(name)} {')
+		mut align := StructDeclAlignment{}
+		mut has_align := false
+		if decl_align := g.struct_decl_alignment_for_name(name) {
+			align = decl_align
+			has_align = true
+		}
+		head := g.struct_decl_head(name)
+		if has_align && g.ccompiler == 'msvc' {
+			// MSVC takes the alignment between the tag and the name, and has no GNU
+			// attributes (the preamble defines `__attribute__` away).
+			g.writeln('${head.all_before(' ')} ${struct_decl_alignment_declspec(align)} ${head.all_after(' ')} {')
+		} else {
+			g.writeln('${head} {')
+		}
 		if fields.len == 0 {
 			g.writeln('\tE_STRUCT_DECL;')
 		}
 		for f in fields {
 			g.write_struct_field(name, f)
 		}
-		if align := g.struct_decl_alignment_for_name(name) {
+		if has_align && g.ccompiler != 'msvc' {
 			g.writeln('} ${struct_decl_alignment_attr(align)};')
 		} else {
 			g.writeln('};')