checker: relax the array int index rule, copy Go's behavior

Author: medvednikov

vlib/builtin/array.v

@@ -731,6 +731,31 @@ fn (a array) get(i int) voidptr {
 	}
 }
 
+@[markused]
+fn (a array) get_i64(i i64) voidptr {
+	$if !no_bounds_checking {
+		if i < 0 || i >= i64(a.len) {
+			panic_n2('array.get: index out of range (i,a.len):', i, a.len)
+		}
+	}
+	unsafe {
+		return &u8(a.data) + u64(i) * u64(a.element_size)
+	}
+}
+
+@[markused]
+fn (a array) get_u64(i u64) voidptr {
+	$if !no_bounds_checking {
+		if i >= u64(a.len) {
+			panic('array.get: index out of range (i,a.len): ' + i.str() + ', ' +
+				impl_i64_to_string(a.len))
+		}
+	}
+	unsafe {
+		return &u8(a.data) + i * u64(a.element_size)
+	}
+}
+
 @[markused]
 fn (a array) get_ni(i int) voidptr {
 	return a.get(v_ni_index(i, a.len))
@@ -746,6 +771,26 @@ fn (a array) get_with_check(i int) voidptr {
 	}
 }
 
+@[markused]
+fn (a array) get_with_check_i64(i i64) voidptr {
+	if i < 0 || i >= i64(a.len) {
+		return 0
+	}
+	unsafe {
+		return &u8(a.data) + u64(i) * u64(a.element_size)
+	}
+}
+
+@[markused]
+fn (a array) get_with_check_u64(i u64) voidptr {
+	if i >= u64(a.len) {
+		return 0
+	}
+	unsafe {
+		return &u8(a.data) + i * u64(a.element_size)
+	}
+}
+
 @[markused]
 fn (a array) get_with_check_ni(i int) voidptr {
 	return a.get_with_check(v_ni_index(i, a.len))
@@ -1044,6 +1089,27 @@ fn (mut a array) set(i int, val voidptr) {
 	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(i), val, a.element_size) }
 }
 
+@[markused]
+fn (mut a array) set_i64(i i64, val voidptr) {
+	$if !no_bounds_checking {
+		if i < 0 || i >= i64(a.len) {
+			panic_n2('array.set: index out of range (i,a.len):', i, a.len)
+		}
+	}
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * u64(i), val, a.element_size) }
+}
+
+@[markused]
+fn (mut a array) set_u64(i u64, val voidptr) {
+	$if !no_bounds_checking {
+		if i >= u64(a.len) {
+			panic('array.set: index out of range (i,a.len): ' + i.str() + ', ' +
+				impl_i64_to_string(a.len))
+		}
+	}
+	unsafe { vmemcpy(&u8(a.data) + u64(a.element_size) * i, val, a.element_size) }
+}
+
 @[markused]
 fn (mut a array) set_ni(i int, val voidptr) {
 	a.set(v_ni_index(i, a.len), val)

vlib/builtin/builtin.c.v

@@ -79,6 +79,28 @@ fn v_fixed_index(i int, len int) int {
 	return i
 }
 
+@[inline; markused]
+fn v_fixed_index_i64(i i64, len int) int {
+	$if !no_bounds_checking {
+		if i < 0 || i >= i64(len) {
+			panic('fixed array index out of range (index: ' + i.str() + ', len: ' + i64(len).str() +
+				')')
+		}
+	}
+	return int(i)
+}
+
+@[inline; markused]
+fn v_fixed_index_u64(i u64, len int) int {
+	$if !no_bounds_checking {
+		if i >= u64(len) {
+			panic('fixed array index out of range (index: ' + i.str() + ', len: ' + i64(len).str() +
+				')')
+		}
+	}
+	return int(i)
+}
+
 @[inline; markused]
 fn v_fixed_index_ni(i int, len int) int {
 	return v_fixed_index(v_ni_index(i, len), len)

vlib/builtin/js/map_test.js.v

@@ -923,7 +923,7 @@ fn test_i64_keys() {
 	assert m.len == end
 	keys := m.keys()
 	for i in i64(0) .. end {
-		assert keys[i] == i
+		assert keys[int(i)] == i
 	}
 	for i in i64(0) .. end {
 		m.delete(i)
@@ -949,7 +949,7 @@ fn test_u64_keys() {
 	assert u64(m.len) == end
 	keys := m.keys()
 	for i in u64(0) .. end {
-		assert keys[i] == i
+		assert keys[int(i)] == i
 	}
 	for i in u64(0) .. end {
 		m.delete(i)

vlib/builtin/string.v

@@ -2156,6 +2156,27 @@ fn (s string) at(idx int) u8 {
 	return unsafe { s.str[idx] }
 }
 
+@[markused]
+fn (s string) at_i64(idx i64) u8 {
+	$if !no_bounds_checking {
+		if idx < 0 || idx >= i64(s.len) {
+			panic_n2('string index out of range(idx,s.len):', idx, s.len)
+		}
+	}
+	return unsafe { s.str[int(idx)] }
+}
+
+@[markused]
+fn (s string) at_u64(idx u64) u8 {
+	$if !no_bounds_checking {
+		if idx >= u64(s.len) {
+			panic('string index out of range(idx,s.len): ' + idx.str() + ', ' +
+				impl_i64_to_string(s.len))
+		}
+	}
+	return unsafe { s.str[int(idx)] }
+}
+
 @[markused]
 fn (s string) at_ni(idx int) u8 {
 	return s.at(v_ni_index(idx, s.len))
@@ -2172,6 +2193,26 @@ fn (s string) at_with_check(idx int) ?u8 {
 	}
 }
 
+@[markused]
+fn (s string) at_with_check_i64(idx i64) ?u8 {
+	if idx < 0 || idx >= i64(s.len) {
+		return none
+	}
+	unsafe {
+		return s.str[int(idx)]
+	}
+}
+
+@[markused]
+fn (s string) at_with_check_u64(idx u64) ?u8 {
+	if idx >= u64(s.len) {
+		return none
+	}
+	unsafe {
+		return s.str[int(idx)]
+	}
+}
+
 @[markused]
 fn (s string) at_with_check_ni(idx int) ?u8 {
 	return s.at_with_check(v_ni_index(idx, s.len))

vlib/v/checker/checker.v

@@ -7707,7 +7707,7 @@ fn (c &Checker) internal_index_type(index_type ast.Type) ast.Type {
 	return internal_index_type
 }
 
-fn (mut c Checker) check_internal_index_type(index ast.Expr, index_type ast.Type, typ_sym &ast.TypeSymbol) bool {
+fn (mut c Checker) check_internal_index_type(index ast.Expr, index_type ast.Type, typ_sym &ast.TypeSymbol, range_index bool, is_gated bool) bool {
 	if c.pref.translated || c.file.is_translated {
 		return true
 	}
@@ -7720,6 +7720,9 @@ fn (mut c Checker) check_internal_index_type(index ast.Expr, index_type ast.Type
 		}
 		return true
 	}
+	if c.pref.backend == .c && !range_index && !is_gated {
+		return true
+	}
 	int_size, _ := c.table.type_size(ast.int_type_idx)
 	internal_index_size, _ := c.table.type_size(internal_index_type.idx_type())
 	if internal_index_size > int_size {
@@ -7758,7 +7761,7 @@ fn (mut c Checker) check_index(typ_sym &ast.TypeSymbol, index ast.Expr, index_ty
 			c.error('cannot use Option or Result as index ${type_str}', index.pos())
 			return
 		}
-		if !c.check_internal_index_type(index, index_type, typ_sym) {
+		if !c.check_internal_index_type(index, index_type, typ_sym, range_index, is_gated) {
 			return
 		}
 		if index is ast.IntegerLiteral && !is_gated {

vlib/v/checker/tests/index_expr_implicit_int_downcast_err.out

@@ -1,20 +1,6 @@
-vlib/v/checker/tests/index_expr_implicit_int_downcast_err.vv:10:12: error: cannot use `u64` as string index type `int`, use an explicit cast like `int(expr)`
-    8 |     _ = s[int(idx_u64)]
-    9 |     _ = a[idx_u32]
-   10 |     println(s[idx_u64])
-      |               ~~~~~~~
-   11 |     println(a[idx_i64])
-   12 |     println(a[idx_usize..])
-vlib/v/checker/tests/index_expr_implicit_int_downcast_err.vv:11:12: error: cannot use `i64` as index type `int`, use an explicit cast like `int(expr)`
-    9 |     _ = a[idx_u32]
-   10 |     println(s[idx_u64])
-   11 |     println(a[idx_i64])
-      |               ~~~~~~~
-   12 |     println(a[idx_usize..])
-   13 | }
-vlib/v/checker/tests/index_expr_implicit_int_downcast_err.vv:12:12: error: cannot use `usize` as index type `int`, use an explicit cast like `int(expr)`
-   10 |     println(s[idx_u64])
-   11 |     println(a[idx_i64])
-   12 |     println(a[idx_usize..])
+vlib/v/checker/tests/index_expr_implicit_int_downcast_err.vv:4:12: error: cannot use `usize` as index type `int`, use an explicit cast like `int(expr)`
+    2 |     a := [1, 2, 3]
+    3 |     idx_usize := usize(1)
+    4 |     println(a[idx_usize..])
       |               ~~~~~~~~~
-   13 | }
+    5 | }

vlib/v/checker/tests/index_expr_implicit_int_downcast_err.vv

@@ -1,13 +1,5 @@
 fn main() {
-	s := 'abc'
 	a := [1, 2, 3]
-	idx_u64 := u64(1)
-	idx_u32 := u32(1)
-	idx_i64 := i64(1)
 	idx_usize := usize(1)
-	_ = s[int(idx_u64)]
-	_ = a[idx_u32]
-	println(s[idx_u64])
-	println(a[idx_i64])
 	println(a[idx_usize..])
 }