v3: preserve import order and validate declared casts

Author: medvednikov

vlib/v3/gen/fastc/fastc.v

@@ -274,6 +274,7 @@ mut:
 struct FastcSourceHeader {
 	module_name   string
 	imports       map[string]string
+	import_order  []string
 	blank_imports []string
 	has_globals   bool
 }
@@ -736,6 +737,7 @@ fn fastc_resolve_source_files(paths []string, prefs &pref.Preferences) ![]FastcS
 			header = FastcSourceHeader{
 				module_name:   queued.module_name
 				imports:       header.imports
+				import_order:  header.import_order
 				blank_imports: header.blank_imports
 				has_globals:   header.has_globals
 			}
@@ -773,9 +775,12 @@ fn fastc_resolve_source_files(paths []string, prefs &pref.Preferences) ![]FastcS
 }
 
 fn fastc_header_imported_modules(header FastcSourceHeader) []string {
-	mut modules := header.imports.values()
-	modules << header.blank_imports
-	return modules
+	if header.import_order.len > 0 {
+		return header.import_order.clone()
+	}
+	mut fallback := header.imports.values()
+	fallback << header.blank_imports
+	return fallback
 }
 
 fn fastc_sources_in_dependency_order(sources []FastcSourceFile) ![]FastcSourceFile {
@@ -870,7 +875,6 @@ fn fastc_append_module_sources(module_name string, sources []FastcSourceFile, mu
 			}
 		}
 	}
-	dependencies.sort()
 	for dependency in dependencies {
 		fastc_append_module_sources(dependency, sources, mut visiting, mut visited, mut ordered)!
 	}
@@ -897,6 +901,7 @@ fn fastc_scan_source_header(source string, path string, prefs &pref.Preferences)
 	scan.init(file, source)
 	mut module_name := ''
 	mut imports := map[string]string{}
+	mut import_order := []string{}
 	mut blank_imports := []string{}
 	mut has_globals := false
 	mut brace_depth := 0
@@ -953,6 +958,9 @@ fn fastc_scan_source_header(source string, path string, prefs &pref.Preferences)
 				fastc_register_import_alias(import_path, alias, path, mut imports, mut
 					blank_imports)!
 				fastc_register_selective_imports(import_path, selected_names, path, mut imports)!
+				if import_path !in import_order {
+					import_order << import_path
+				}
 				tok = next_token
 			}
 			if tok == .rpar {
@@ -963,18 +971,28 @@ fn fastc_scan_source_header(source string, path string, prefs &pref.Preferences)
 		import_path, alias, selected_names, next_token := fastc_scan_import(mut scan, tok, path)!
 		fastc_register_import_alias(import_path, alias, path, mut imports, mut blank_imports)!
 		fastc_register_selective_imports(import_path, selected_names, path, mut imports)!
+		if import_path !in import_order {
+			import_order << import_path
+		}
 		tok = next_token
 	}
 	if module_name == '' {
 		module_name = 'main'
 	}
 	if prefs.building_v && prefs.backend == 'fastc' && imports['driver'] == 'v3.driver'
 		&& 'fastcdriver' in imports {
-		imports['driver'] = imports['fastcdriver']
+		fastcdriver_module := imports['fastcdriver']
+		imports['driver'] = fastcdriver_module
+		for i, imported_module in import_order {
+			if imported_module == 'v3.driver' {
+				import_order[i] = fastcdriver_module
+			}
+		}
 	}
 	return FastcSourceHeader{
 		module_name:   module_name
 		imports:       imports
+		import_order:  import_order
 		blank_imports: blank_imports
 		has_globals:   has_globals
 	}
@@ -10685,6 +10703,19 @@ fn (g &Parser) is_enum_type_name(name string) bool {
 	return g.declared_kinds[type_key] == .enum_
 }
 
+fn (g &Parser) declared_cast_type_key(tokens []FastcExpressionToken, name_index int) ?string {
+	if name_index >= 2 && tokens[name_index - 1].tok == .dot && tokens[name_index - 2].tok == .name {
+		module_name := g.imports[tokens[name_index - 2].lit] or { return none }
+		type_key := fastc_type_key(module_name, tokens[name_index].lit)
+		return if type_key in g.declared_types { type_key } else { none }
+	}
+	if name_index > 0 && tokens[name_index - 1].tok == .dot {
+		return none
+	}
+	return fastc_resolve_declared_type_key(g.module_name, tokens[name_index].lit, g.imports,
+		g.declared_types)
+}
+
 fn (g &Parser) validate_expression_calls(tokens []FastcExpressionToken) ! {
 	mut i := 0
 	for i + 1 < tokens.len {
@@ -10824,16 +10855,15 @@ fn (g &Parser) validate_expression_calls(tokens []FastcExpressionToken) ! {
 				i = call_end + 1
 				continue
 			}
-			if i == 0 || tokens[i - 1].tok != .dot {
-				if _ := fastc_resolve_declared_type_key(g.module_name, name, g.imports,
-					g.declared_types)
-				{
-					if call_args.len != 1 {
-						return g.unsupported('cast `${name}` with ${call_args.len} arguments')
-					}
-					i = call_end + 1
-					continue
+			if type_key := g.declared_cast_type_key(tokens, i) {
+				if call_args.len != 1 {
+					return g.unsupported('cast `${name}` with ${call_args.len} arguments')
 				}
+				g.validate_declared_cast(type_key, call_args[0], tokens[i].unsafe_depth > 0)!
+				i = call_end + 1
+				continue
+			}
+			if i == 0 || tokens[i - 1].tok != .dot {
 				if primitive_type := fastc_primitive_c_type(name) {
 					if call_args.len != 1 {
 						return g.unsupported('cast `${name}` with ${call_args.len} arguments')
@@ -10967,6 +10997,51 @@ fn (g &Parser) validate_primitive_cast(target_type string, operand []FastcExpres
 	return g.unsupported('cast from `${actual_type}` to `${target_type}`')
 }
 
+fn (g &Parser) validate_declared_cast(type_key string, operand []FastcExpressionToken, in_unsafe bool) ! {
+	if g.selfhost {
+		return
+	}
+	target_type := fastc_c_declared_type_name(type_key)
+	actual_type := fastc_normalize_inferred_type(g.infer_expression_type(operand)!)
+	if actual_type == '' {
+		return g.unsupported('unverifiable operand type for cast to `${target_type}`')
+	}
+	match g.declared_kinds[type_key] {
+		.alias_ {
+			target_base := g.underlying_alias_type(target_type)
+			if target_base == target_type {
+				return g.unsupported('unverifiable declared alias cast to `${target_type}`')
+			}
+			if g.declared_kinds[g.semantic_type_key(target_base)] == .enum_ {
+				return g.validate_declared_enum_cast(target_base, actual_type, in_unsafe)
+			}
+			actual_base := g.underlying_alias_type(actual_type)
+			if actual_type == target_type || actual_base == target_base
+				|| g.primitive_cast_types_are_compatible(actual_base, target_base, in_unsafe) {
+				return
+			}
+			return g.unsupported('cast from `${actual_type}` to `${target_type}` (alias to `${target_base}`)')
+		}
+		.enum_ {
+			return g.validate_declared_enum_cast(target_type, actual_type, in_unsafe)
+		}
+		else {}
+	}
+}
+
+fn (g &Parser) validate_declared_enum_cast(target_type string, actual_type string, in_unsafe bool) ! {
+	actual_base := g.underlying_alias_type(actual_type)
+	if g.semantic_type_key(actual_base) == g.semantic_type_key(target_type) {
+		return
+	}
+	if !fastc_is_integer_expression_type(actual_base) {
+		return g.unsupported('cast from `${actual_type}` to enum `${target_type}`')
+	}
+	if !in_unsafe {
+		return g.unsupported('cast from `${actual_type}` to enum `${target_type}` outside an `unsafe` block')
+	}
+}
+
 fn (g &Parser) primitive_cast_types_are_compatible(actual_type string, target_type string, in_unsafe bool) bool {
 	if actual_type == target_type {
 		return true

vlib/v3/gen/fastc/fastc_test.v

@@ -160,6 +160,7 @@ fn init() {
 		panic(err)
 	}
 	assert header.blank_imports == ['alpha', 'beta']
+	assert header.import_order == ['alpha', 'beta']
 	assert '_' !in header.imports
 	c_source := generate_files([main_file], prefs) or { panic(err) }
 	assert c_source.contains('\talpha__init();'), c_source
@@ -1111,6 +1112,85 @@ pub fn ping() {}
 	assert run_result.output.trim_space() == 'dep init\nmain init\nmain\nmain defer\nmain cleanup\ndep cleanup'
 }
 
+fn test_module_lifecycle_preserves_source_import_order() {
+	root := os.join_path(os.vtmp_dir(), 'v3_fastc_import_order_${os.getpid()}')
+	os.rmdir_all(root) or {}
+	os.mkdir_all(os.join_path(root, 'zed')) or { panic(err) }
+	os.mkdir_all(os.join_path(root, 'alpha')) or { panic(err) }
+	defer {
+		os.rmdir_all(root) or {}
+	}
+	main_file := os.join_path(root, 'main.v')
+	os.write_file(main_file, "module main
+
+import zed
+import alpha
+
+fn main() {
+	zed.ping()
+	alpha.ping()
+	println('main')
+}
+") or {
+		panic(err)
+	}
+	os.write_file(os.join_path(root, 'zed', 'zed.v'), "module zed
+
+fn init() {
+	println('zed init')
+}
+
+fn cleanup() {
+	println('zed cleanup')
+}
+
+pub fn ping() {}
+") or {
+		panic(err)
+	}
+	os.write_file(os.join_path(root, 'alpha', 'alpha.v'), "module alpha
+
+fn init() {
+	println('alpha init')
+}
+
+fn cleanup() {
+	println('alpha cleanup')
+}
+
+pub fn ping() {}
+") or {
+		panic(err)
+	}
+	mut prefs := pref.new_preferences()
+	prefs.module_search_paths = [root]
+	header := fastc_scan_source_header(os.read_file(main_file) or { panic(err) }, main_file, prefs) or {
+		panic(err)
+	}
+	assert header.import_order == ['zed', 'alpha']
+	c_source := generate_files([main_file], prefs) or { panic(err) }
+	startup_source := c_source.all_after('static void v_fastc_init_globals(void) {')
+	zed_init := startup_source.index('\tzed__init();') or { -1 }
+	alpha_init := startup_source.index('\talpha__init();') or { -1 }
+	assert zed_init >= 0, c_source
+	assert alpha_init > zed_init, c_source
+	cleanup_source := c_source.all_after('static void v_fastc_cleanup_modules(void) {')
+	alpha_cleanup := cleanup_source.index('\talpha__cleanup();') or { -1 }
+	zed_cleanup := cleanup_source.index('\tzed__cleanup();') or { -1 }
+	assert alpha_cleanup >= 0, c_source
+	assert zed_cleanup > alpha_cleanup, 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() == 'zed init\nalpha init\nmain\nalpha cleanup\nzed cleanup'
+}
+
 fn test_module_initializer_signatures_are_validated() {
 	prefs := pref.new_preferences()
 	for source in [
@@ -1733,6 +1813,46 @@ fn main() {
 	assert c_source.contains('println(((bool)(0)));'), c_source
 }
 
+fn test_declared_cast_operands_are_validated() {
+	prefs := pref.new_preferences()
+	for source, expected in {
+		'module main\ntype MyType = string\nfn main() { println(MyType(5)) }\n':       'alias to `string`'
+		"module main\nenum Color { red blue }\nfn main() { println(Color('red')) }\n": 'to enum `Color`'
+		'module main\nenum Color { red blue }\nfn main() { println(Color(1)) }\n':     'outside an `unsafe` block'
+	} {
+		mut message := ''
+		_ := generate(source, 'invalid_declared_cast.v', prefs) or {
+			message = err.msg()
+			''
+		}
+		assert message.contains(expected), message
+	}
+
+	c_source := generate("module main
+
+type Label = string
+type Count = int
+
+enum Color {
+	red
+	blue
+}
+
+fn main() {
+	label := Label('ok')
+	count := Count(2)
+	color := unsafe { Color(1) }
+	println(label == Label('ok'))
+	println(int(count))
+	println(color)
+}
+",
+		'valid_declared_casts.v', prefs) or { panic(err) }
+	assert c_source.contains('((Label)("ok"))'), c_source
+	assert c_source.contains('((Count)(2))'), c_source
+	assert c_source.contains('((Color)(1))'), c_source
+}
+
 fn test_defer_is_emitted_when_its_lexical_scope_exits() {
 	prefs := pref.new_preferences()
 	c_source := generate('module main