v3: preserve signed fastc integer literals

Author: medvednikov

vlib/v3/gen/fastc/fastc.v

@@ -4452,7 +4452,7 @@ fn (mut g Parser) parse_declaration_after_name(name string, is_mut bool) ! {
 
 fn fastc_normalize_inferred_type(typ string) string {
 	return match typ {
-		'integer literal' { 'int' }
+		'integer literal', 'negative integer literal' { 'int' }
 		'float literal' { 'f64' }
 		'nil' { 'voidptr' }
 		else { typ }
@@ -9311,6 +9311,9 @@ fn (g &Parser) infer_expression_type(tokens []FastcExpressionToken) !string {
 		if !fastc_is_numeric_expression_type(operand_type) {
 			return g.unsupported('arithmetic `${tokens[start].tok.str()}` on non-numeric type `${operand_type}`')
 		}
+		if tokens[start].tok == .minus && operand_type == 'integer literal' {
+			return 'negative integer literal'
+		}
 		return operand_type
 	}
 	if tokens[start].tok in [.amp, .and] {
@@ -9583,19 +9586,36 @@ fn fastc_number_expression_type(literal string) string {
 		&& clean.contains_any('eE')) {
 		return 'float literal'
 	}
+	if clean.starts_with('-') {
+		return 'negative integer literal'
+	}
 	return 'integer literal'
 }
 
 fn fastc_common_arithmetic_type(left string, right string) string {
 	if left == right && fastc_is_numeric_expression_type(left) {
 		return left
 	}
-	if left == 'integer literal' && fastc_is_integer_type(right) {
+	if left == 'negative integer literal' && fastc_is_unsigned_integer_type(right) {
+		return ''
+	}
+	if right == 'negative integer literal' && fastc_is_unsigned_integer_type(left) {
+		return ''
+	}
+	if fastc_is_integer_literal_expression_type(left) && fastc_is_integer_type(right) {
 		return right
 	}
-	if right == 'integer literal' && fastc_is_integer_type(left) {
+	if fastc_is_integer_literal_expression_type(right) && fastc_is_integer_type(left) {
 		return left
 	}
+	if fastc_is_integer_literal_expression_type(left)
+		&& fastc_is_integer_literal_expression_type(right) {
+		return if left == 'negative integer literal' || right == 'negative integer literal' {
+			'negative integer literal'
+		} else {
+			'integer literal'
+		}
+	}
 	if left == 'float literal' && right in ['f32', 'f64'] {
 		return right
 	}
@@ -9606,11 +9626,16 @@ fn fastc_common_arithmetic_type(left string, right string) string {
 }
 
 fn fastc_is_numeric_expression_type(typ string) bool {
-	return typ in ['integer literal', 'float literal', 'f32', 'f64'] || fastc_is_integer_type(typ)
+	return fastc_is_integer_literal_expression_type(typ) || typ in ['float literal', 'f32', 'f64']
+		|| fastc_is_integer_type(typ)
 }
 
 fn fastc_is_integer_expression_type(typ string) bool {
-	return typ == 'integer literal' || fastc_is_integer_type(typ)
+	return fastc_is_integer_literal_expression_type(typ) || fastc_is_integer_type(typ)
+}
+
+fn fastc_is_integer_literal_expression_type(typ string) bool {
+	return typ in ['integer literal', 'negative integer literal']
 }
 
 fn fastc_call_types_are_compatible(actual string, expected string) bool {
@@ -9620,6 +9645,9 @@ fn fastc_call_types_are_compatible(actual string, expected string) bool {
 	if actual == 'integer literal' {
 		return fastc_is_integer_type(expected)
 	}
+	if actual == 'negative integer literal' {
+		return fastc_is_integer_type(expected) && !fastc_is_unsigned_integer_type(expected)
+	}
 	if actual == 'float literal' {
 		return expected in ['f32', 'f64']
 	}
@@ -9647,6 +9675,9 @@ fn fastc_selfhost_types_are_compatible(actual string, expected string) bool {
 		|| (expected_base == 'map' && actual_base.starts_with('Map_')) {
 		return true
 	}
+	if actual == 'negative integer literal' && fastc_is_unsigned_integer_type(expected) {
+		return false
+	}
 	if fastc_is_integer_expression_type(actual) && fastc_is_integer_type(expected) {
 		return true
 	}
@@ -9711,6 +9742,10 @@ fn fastc_is_integer_type(typ string) bool {
 		'u32', 'u64', 'unsigned int', 'usize']
 }
 
+fn fastc_is_unsigned_integer_type(typ string) bool {
+	return typ in ['byte', 'u8', 'u16', 'u32', 'u64', 'unsigned int', 'usize']
+}
+
 fn fastc_nondecimal_literal_is_type_sensitive(literal string) bool {
 	clean := literal.replace('_', '')
 	if clean.len <= 2 || clean[0] != `0` {

vlib/v3/gen/fastc/fastc_test.v

@@ -353,6 +353,60 @@ fn main() {
 	assert c_source.contains('count+=3;')
 }
 
+fn test_negative_integer_literals_are_rejected_for_unsigned_targets() {
+	prefs := pref.new_preferences()
+	for source in [
+		'module main\nfn take(x u32) { println(x) }\nfn main() { take(-1) }\n',
+		'module main\nfn main() { mut value := u32(0); value = -1; println(value) }\n',
+		'module main\nfn value() u32 { return -1 }\nfn main() { println(value()) }\n',
+	] {
+		mut message := ''
+		_ := generate(source, 'negative_unsigned_literal.v', prefs) or {
+			message = err.msg()
+			''
+		}
+		assert message.contains('negative integer literal'), message
+		assert message.contains('u32'), message
+	}
+
+	c_source := generate('module main
+
+fn take(x u32) {
+	println(x)
+}
+
+fn value() u32 {
+	return 1
+}
+
+fn take_signed(x int) {
+	println(x)
+}
+
+fn signed_value() int {
+	return -1
+}
+
+fn main() {
+	mut number := u32(0)
+	number = 1
+	take(1)
+	println(value())
+	mut signed := 0
+	signed = -1
+	take_signed(-1)
+	println(signed_value())
+}
+',
+		'positive_unsigned_literals.v', prefs) or { panic(err) }
+	assert c_source.contains('number=1;')
+	assert c_source.contains('take(1);')
+	assert c_source.contains('return 1;')
+	assert c_source.contains('signed=-1;')
+	assert c_source.contains('take_signed(-1);')
+	assert c_source.contains('return -1;')
+}
+
 fn test_main_must_not_return_a_value() {
 	prefs := pref.new_preferences()
 	mut message := ''