v3: enforce fastc initialization semantics

Author: medvednikov

vlib/v3/gen/fastc/fastc.v

@@ -259,6 +259,7 @@ struct FastcStructField {
 	name           string
 	typ            string
 	is_public      bool
+	is_required    bool
 	module_name    string
 	path           string
 	imports        map[string]string
@@ -689,6 +690,56 @@ fn fastc_resolve_source_files(paths []string, prefs &pref.Preferences) ![]FastcS
 	return sources
 }
 
+fn fastc_sources_in_dependency_order(sources []FastcSourceFile) ![]FastcSourceFile {
+	mut module_order := []string{}
+	for source_file in sources {
+		module_name := source_file.header.module_name
+		if module_name !in module_order {
+			module_order << module_name
+		}
+	}
+	mut visiting := []string{}
+	mut visited := []string{}
+	mut ordered := []FastcSourceFile{cap: sources.len}
+	for module_name in module_order {
+		fastc_append_module_sources(module_name, sources, mut visiting, mut visited, mut ordered)!
+	}
+	return ordered
+}
+
+fn fastc_append_module_sources(module_name string, sources []FastcSourceFile, mut visiting []string, mut visited []string, mut ordered []FastcSourceFile) ! {
+	if module_name in visited {
+		return
+	}
+	if module_name in visiting {
+		return error('fastc parser does not support cyclic module dependency involving `${module_name}`')
+	}
+	visiting << module_name
+	mut dependencies := []string{}
+	for source_file in sources {
+		if source_file.header.module_name != module_name {
+			continue
+		}
+		imports := source_file.header.imports.clone()
+		for dependency in imports.values() {
+			if dependency != module_name && dependency !in dependencies {
+				dependencies << dependency
+			}
+		}
+	}
+	dependencies.sort()
+	for dependency in dependencies {
+		fastc_append_module_sources(dependency, sources, mut visiting, mut visited, mut ordered)!
+	}
+	for source_file in sources {
+		if source_file.header.module_name == module_name {
+			ordered << source_file
+		}
+	}
+	visiting.delete(visiting.len - 1)
+	visited << module_name
+}
+
 fn fastc_source_file_matches_backend(path string) bool {
 	return !path.ends_with('.arm64.v') && !path.ends_with('.amd64.v')
 		&& !path.ends_with('.native.v') && !path.ends_with('.wasm.v') && !path.ends_with('.rv64.v')
@@ -1004,7 +1055,8 @@ fn collect_global_names(source string, path string, module_name string, prefs &p
 fn fastc_generate_global_declarations(sources []FastcSourceFile, prefs &pref.Preferences, declared_types map[string]bool, declared_kinds map[string]FastcDeclaredTypeKind, struct_fields map[string]map[string]string, struct_field_info map[string][]FastcStructField, functions map[string]FastcFunctionSignature, constants map[string]string, public_constants map[string]bool, constant_types map[string]string, globals map[string]string, mut global_types map[string]string) !FastcGlobalDeclarations {
 	mut out := strings.new_builder(1024)
 	mut initializers := strings.new_builder(1024)
-	for source_file in sources {
+	ordered_sources := fastc_sources_in_dependency_order(sources)!
+	for source_file in ordered_sources {
 		mut file_set := token.FileSet.new()
 		mut file := file_set.add_file(source_file.path, source_file.source.len)
 		file.index_lines(source_file.source)
@@ -1543,6 +1595,12 @@ fn fastc_emit_struct_declaration(mut scan scanner.Scanner, is_union bool, source
 		}
 		tok = next_token
 		fastc_register_composite_type(field_type, mut composite_types)
+		mut is_required := false
+		for tok == .attribute {
+			mut attribute_is_required := false
+			tok, attribute_is_required = fastc_scan_struct_field_attribute(mut scan)!
+			is_required = is_required || attribute_is_required
+		}
 		mut default_source := ''
 		if tok == .assign {
 			first_default_token := scan.scan()
@@ -1569,6 +1627,7 @@ fn fastc_emit_struct_declaration(mut scan scanner.Scanner, is_union bool, source
 				name:           field_name
 				typ:            field_type
 				is_public:      fields_are_public
+				is_required:    is_required
 				module_name:    source_file.header.module_name
 				path:           source_file.path
 				imports:        source_file.header.imports.clone()
@@ -1662,8 +1721,16 @@ fn fastc_emit_enum_declaration(mut scan scanner.Scanner, source_file FastcSource
 		tok = scan.scan()
 		if tok == .assign {
 			tok = scan.scan()
+			mut sign := 1
+			if tok in [.plus, .minus] {
+				sign = if tok == .minus { -1 } else { 1 }
+				tok = scan.scan()
+			}
 			if tok == .number {
 				value = scan.lit.int()
+				if sign < 0 {
+					value = -value
+				}
 				tok = scan.scan()
 			} else {
 				tok = fastc_skip_field_default_from_token(mut scan, tok)!
@@ -1832,6 +1899,27 @@ fn fastc_skip_attribute(mut scan scanner.Scanner) !token.Token {
 	return tok
 }
 
+fn fastc_scan_struct_field_attribute(mut scan scanner.Scanner) !(token.Token, bool) {
+	mut tok := scan.scan()
+	mut depth := 1
+	mut is_required := false
+	for depth > 0 {
+		if tok == .eof {
+			return error('fastc parser does not support unfinished struct field attribute')
+		}
+		if tok == .name && scan.lit == 'required' {
+			is_required = true
+		}
+		if tok == .lsbr {
+			depth++
+		} else if tok == .rsbr {
+			depth--
+		}
+		tok = scan.scan()
+	}
+	return tok, is_required
+}
+
 fn fastc_skip_balanced_tokens(mut scan scanner.Scanner, first token.Token, open token.Token, close token.Token) !token.Token {
 	mut tok := first
 	mut depth := 0
@@ -4108,6 +4196,9 @@ fn (mut g Parser) parse_for() !bool {
 					|| !fastc_is_integer_expression_type(end_expression_type) {
 					return g.unsupported('range bounds of types `${start_expression_type}` and `${end_expression_type}` must both be integers')
 				}
+				if !fastc_range_types_are_compatible(start_expression_type, end_expression_type) {
+					return g.unsupported('range bounds of types `${start_expression_type}` and `${end_expression_type}` must have compatible integer types')
+				}
 				if start_value := fastc_integer_literal_value(start_expression) {
 					if end_value := fastc_integer_literal_value(end_expression) {
 						if start_value >= end_value {
@@ -9742,6 +9833,8 @@ fn (g &Parser) validate_struct_literal_field_visibility(tokens []FastcExpression
 	}
 	close := fastc_matching_delimiter(tokens, open, .lcbr, .rcbr) or { return }
 	mut index := open + 1
+	mut initialized_fields := map[string]bool{}
+	mut has_update := false
 	for index < close {
 		for index < close && tokens[index].tok in [.semicolon, .comma] {
 			index++
@@ -9750,6 +9843,7 @@ fn (g &Parser) validate_struct_literal_field_visibility(tokens []FastcExpression
 			break
 		}
 		if tokens[index].tok == .ellipsis {
+			has_update = true
 			index++
 			for index < close && tokens[index].tok !in [.semicolon, .comma] {
 				index++
@@ -9761,6 +9855,7 @@ fn (g &Parser) validate_struct_literal_field_visibility(tokens []FastcExpression
 		}
 		field_name := tokens[index].lit
 		field := g.struct_field_metadata(c_type, field_name) or { return }
+		initialized_fields[field_name] = true
 		if !g.struct_field_is_visible(field) {
 			type_name := g.semantic_type_key(c_type).all_after_last('.')
 			return g.unsupported('private field `${type_name}.${field.name}` from imported module `${field.module_name}`')
@@ -9802,6 +9897,14 @@ fn (g &Parser) validate_struct_literal_field_visibility(tokens []FastcExpression
 			index++
 		}
 	}
+	if !has_update {
+		for field in g.struct_field_info[layout_type] {
+			if field.is_required && field.name !in initialized_fields {
+				type_name := g.semantic_type_key(c_type).all_after_last('.')
+				return g.unsupported('field `${type_name}.${field.name}` must be initialized')
+			}
+		}
+	}
 }
 
 fn fastc_matching_rpar(tokens []FastcExpressionToken, open int) ?int {
@@ -10424,11 +10527,40 @@ fn fastc_number_expression_type(literal string) string {
 }
 
 fn fastc_integer_literal_value(tokens []FastcExpressionToken) ?i64 {
-	if tokens.len != 1 || tokens[0].tok != .number
-		|| fastc_number_expression_type(tokens[0].lit) != 'integer literal' {
+	mut sign := i64(1)
+	mut number_index := 0
+	if tokens.len == 2 && tokens[0].tok in [.plus, .minus] {
+		sign = if tokens[0].tok == .minus { -1 } else { 1 }
+		number_index = 1
+	} else if tokens.len != 1 {
 		return none
 	}
-	return tokens[0].lit.replace('_', '').i64()
+	if tokens[number_index].tok != .number
+		|| fastc_number_expression_type(tokens[number_index].lit) != 'integer literal' {
+		return none
+	}
+	mut value := tokens[number_index].lit.replace('_', '').i64()
+	if sign < 0 {
+		value = -value
+	}
+	return value
+}
+
+fn fastc_range_types_are_compatible(left string, right string) bool {
+	if left == right {
+		return true
+	}
+	if fastc_is_integer_literal_expression_type(left)
+		&& fastc_is_integer_literal_expression_type(right) {
+		return true
+	}
+	if fastc_is_integer_literal_expression_type(left) {
+		return fastc_call_types_are_compatible(left, right)
+	}
+	if fastc_is_integer_literal_expression_type(right) {
+		return fastc_call_types_are_compatible(right, left)
+	}
+	return false
 }
 
 fn fastc_common_arithmetic_type(left string, right string) string {

vlib/v3/gen/fastc/fastc_test.v

@@ -263,6 +263,40 @@ fn main() {
 	assert c_source.contains('__v_fastc_struct_default.retries=(default_retries());'), c_source
 }
 
+fn test_required_struct_fields_must_be_initialized() {
+	mut prefs := pref.new_preferences()
+	prefs.building_v = true
+	mut message := ''
+	_ := generate('module main
+
+struct Config {
+	name string @[required]
+}
+
+fn main() {
+	Config{}
+}
+',
+		'missing_required_struct_field.v', prefs) or {
+		message = err.msg()
+		''
+	}
+	assert message.contains('field `Config.name` must be initialized'), message
+
+	generate('module main
+
+struct Config {
+	name string @[required]
+}
+
+fn main() {
+	config := Config{name: "set"}
+	println(config.name)
+}
+',
+		'initialized_required_struct_field.v', prefs) or { panic(err) }
+}
+
 fn test_generate_files_rejects_private_imported_struct_fields() {
 	root := os.join_path(os.vtmp_dir(), 'v3_fastc_private_fields_${os.getpid()}')
 	os.rmdir_all(root) or {}
@@ -389,6 +423,73 @@ fn main() {
 	assert c_source.contains('v_fastc_init_globals();'), c_source
 }
 
+fn test_imported_global_initializers_run_before_importer_globals() {
+	root := os.join_path(os.vtmp_dir(), 'v3_fastc_global_order_${os.getpid()}')
+	os.rmdir_all(root) or {}
+	os.mkdir_all(os.join_path(root, 'dep')) or { panic(err) }
+	defer {
+		os.rmdir_all(root) or {}
+	}
+	main_file := os.join_path(root, 'main.v')
+	dep_file := os.join_path(root, 'dep', 'dep.v')
+	os.write_file(main_file, 'module main
+
+import dep
+
+__global copied = dep.current()
+
+fn main() {
+	println(copied)
+}
+') or {
+		panic(err)
+	}
+	os.write_file(dep_file, 'module dep
+
+__global current_value = 42
+
+pub fn current() int {
+	return current_value
+}
+') or {
+		panic(err)
+	}
+	mut prefs := pref.new_preferences()
+	prefs.module_search_paths = [root]
+	c_source := generate_files([main_file], prefs) or { panic(err) }
+	dependency_initializer := c_source.index('dep__current_value = 42;') or { -1 }
+	importer_initializer := c_source.index('copied = dep__current();') or { -1 }
+	assert dependency_initializer >= 0, c_source
+	assert importer_initializer > dependency_initializer, c_source
+
+	c_file := os.join_path(root, 'program.c')
+	bin_file := os.join_path(root, 'program')
+	os.write_file(c_file, c_source) or { panic(err) }
+	tcc := os.join_path(prefs.vroot, 'thirdparty', 'tcc', 'tcc.exe')
+	compile_result := cmdexec.run(tcc, ['-std=gnu11', '-o', bin_file, c_file])
+	assert compile_result.exit_code == 0, compile_result.output
+	run_result := cmdexec.run(bin_file, [])
+	assert run_result.exit_code == 0, run_result.output
+	assert run_result.output.trim_space() == '42'
+}
+
+fn test_negative_enum_discriminants_are_preserved() {
+	prefs := pref.new_preferences()
+	c_source := generate('module main
+
+enum Foo {
+	a = 1
+	d = -10
+	e
+}
+
+fn main() {}
+',
+		'negative_enum_discriminant.v', prefs) or { panic(err) }
+	assert c_source.contains('#define Foo__d ((Foo)-10)'), c_source
+	assert c_source.contains('#define Foo__e ((Foo)-9)'), c_source
+}
+
 fn test_select_statements_are_rejected() {
 	prefs := pref.new_preferences()
 	mut message := ''
@@ -1025,11 +1126,31 @@ fn test_range_bounds_must_be_integers() {
 	}
 }
 
+fn test_range_bound_integer_types_must_be_compatible() {
+	prefs := pref.new_preferences()
+	for source in [
+		'module main\nfn main() { for i in u64(0) .. -1 { println(i) } }\n',
+		'module main\nfn main() { for i in i64(0) .. u64(3) { println(i) } }\n',
+	] {
+		mut message := ''
+		_ := generate(source, 'incompatible_range_bounds.v', prefs) or {
+			message = err.msg()
+			''
+		}
+		assert message.contains('range bounds of types'), message
+		assert message.contains('must have compatible integer types'), message
+	}
+
+	generate('module main\nfn main() { for i in u64(0) .. 3 { println(i) } }\n',
+		'compatible_range_bound_literal.v', prefs) or { panic(err) }
+}
+
 fn test_literal_range_must_not_be_empty() {
 	prefs := pref.new_preferences()
 	for source in [
 		'module main\nfn main() { for i in 4 .. 2 { println(i) } }\n',
 		'module main\nfn main() { for i in 2 .. 2 { println(i) } }\n',
+		'module main\nfn main() { for i in 4 .. -2 { println(i) } }\n',
 	] {
 		mut message := ''
 		_ := generate(source, 'empty_literal_range.v', prefs) or {