Allow using integer vectors for iteration and make range() use them

core/variant_op.cpp

@@ -78,38 +78,38 @@
 #define TYPE(PREFIX, OP, TYPE) &&PREFIX##_##OP##_##TYPE
 
 /* clang-format off */
-#define TYPES(PREFIX, OP) {                   \
-		TYPE(PREFIX, OP, NIL),                \
-		TYPE(PREFIX, OP, BOOL),               \
-		TYPE(PREFIX, OP, INT),                \
-		TYPE(PREFIX, OP, FLOAT),               \
-		TYPE(PREFIX, OP, STRING),             \
-		TYPE(PREFIX, OP, VECTOR2),            \
-		TYPE(PREFIX, OP, VECTOR2I),            \
-		TYPE(PREFIX, OP, RECT2),              \
-	TYPE(PREFIX, OP, RECT2I),              \
-		TYPE(PREFIX, OP, VECTOR3),            \
-	TYPE(PREFIX, OP, VECTOR3I),            \
-		TYPE(PREFIX, OP, TRANSFORM2D),        \
-		TYPE(PREFIX, OP, PLANE),              \
-		TYPE(PREFIX, OP, QUAT),               \
-		TYPE(PREFIX, OP, AABB),              \
-		TYPE(PREFIX, OP, BASIS),              \
-		TYPE(PREFIX, OP, TRANSFORM),          \
-		TYPE(PREFIX, OP, COLOR),              \
+#define TYPES(PREFIX, OP) {                     \
+		TYPE(PREFIX, OP, NIL),                  \
+		TYPE(PREFIX, OP, BOOL),                 \
+		TYPE(PREFIX, OP, INT),                  \
+		TYPE(PREFIX, OP, FLOAT),                \
+		TYPE(PREFIX, OP, STRING),               \
+		TYPE(PREFIX, OP, VECTOR2),              \
+		TYPE(PREFIX, OP, VECTOR2I),             \
+		TYPE(PREFIX, OP, RECT2),                \
+		TYPE(PREFIX, OP, RECT2I),               \
+		TYPE(PREFIX, OP, VECTOR3),              \
+		TYPE(PREFIX, OP, VECTOR3I),             \
+		TYPE(PREFIX, OP, TRANSFORM2D),          \
+		TYPE(PREFIX, OP, PLANE),                \
+		TYPE(PREFIX, OP, QUAT),                 \
+		TYPE(PREFIX, OP, AABB),                 \
+		TYPE(PREFIX, OP, BASIS),                \
+		TYPE(PREFIX, OP, TRANSFORM),            \
+		TYPE(PREFIX, OP, COLOR),                \
 		TYPE(PREFIX, OP, STRING_NAME),          \
-		TYPE(PREFIX, OP, NODE_PATH),          \
-		TYPE(PREFIX, OP, _RID),               \
-		TYPE(PREFIX, OP, OBJECT),             \
+		TYPE(PREFIX, OP, NODE_PATH),            \
+		TYPE(PREFIX, OP, _RID),                 \
+		TYPE(PREFIX, OP, OBJECT),               \
 		TYPE(PREFIX, OP, CALLABLE),             \
-		TYPE(PREFIX, OP, SIGNAL),             \
-		TYPE(PREFIX, OP, DICTIONARY),         \
-		TYPE(PREFIX, OP, ARRAY),              \
+		TYPE(PREFIX, OP, SIGNAL),               \
+		TYPE(PREFIX, OP, DICTIONARY),           \
+		TYPE(PREFIX, OP, ARRAY),                \
 		TYPE(PREFIX, OP, PACKED_BYTE_ARRAY),    \
-		TYPE(PREFIX, OP, PACKED_INT32_ARRAY),     \
-		TYPE(PREFIX, OP, PACKED_INT64_ARRAY),     \
-		TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY),    \
-		TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY),    \
+		TYPE(PREFIX, OP, PACKED_INT32_ARRAY),   \
+		TYPE(PREFIX, OP, PACKED_INT64_ARRAY),   \
+		TYPE(PREFIX, OP, PACKED_FLOAT32_ARRAY), \
+		TYPE(PREFIX, OP, PACKED_FLOAT64_ARRAY), \
 		TYPE(PREFIX, OP, PACKED_STRING_ARRAY),  \
 		TYPE(PREFIX, OP, PACKED_VECTOR2_ARRAY), \
 		TYPE(PREFIX, OP, PACKED_VECTOR3_ARRAY), \
@@ -3465,6 +3465,14 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const {
 
 			return from < to;
 		} break;
+		case VECTOR2I: {
+			int64_t from = reinterpret_cast<const Vector2i *>(_data._mem)->x;
+			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
+
+			r_iter = from;
+
+			return from < to;
+		} break;
 		case VECTOR3: {
 			int64_t from = reinterpret_cast<const Vector3 *>(_data._mem)->x;
 			int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
@@ -3476,10 +3484,22 @@ bool Variant::iter_init(Variant &r_iter, bool &valid) const {
 				return false;
 			} else if (from < to) {
 				return step > 0;
-			} else {
-				return step < 0;
 			}
-			//return true;
+			return step < 0;
+		} break;
+		case VECTOR3I: {
+			int64_t from = reinterpret_cast<const Vector3i *>(_data._mem)->x;
+			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
+			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
+
+			r_iter = from;
+
+			if (from == to) {
+				return false;
+			} else if (from < to) {
+				return step > 0;
+			}
+			return step < 0;
 		} break;
 		case OBJECT: {
 
@@ -3651,6 +3671,18 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const {
 			r_iter = idx;
 			return true;
 		} break;
+		case VECTOR2I: {
+			int64_t to = reinterpret_cast<const Vector2i *>(_data._mem)->y;
+
+			int64_t idx = r_iter;
+			idx++;
+
+			if (idx >= to)
+				return false;
+
+			r_iter = idx;
+			return true;
+		} break;
 		case VECTOR3: {
 			int64_t to = reinterpret_cast<const Vector3 *>(_data._mem)->y;
 			int64_t step = reinterpret_cast<const Vector3 *>(_data._mem)->z;
@@ -3667,6 +3699,22 @@ bool Variant::iter_next(Variant &r_iter, bool &valid) const {
 			r_iter = idx;
 			return true;
 		} break;
+		case VECTOR3I: {
+			int64_t to = reinterpret_cast<const Vector3i *>(_data._mem)->y;
+			int64_t step = reinterpret_cast<const Vector3i *>(_data._mem)->z;
+
+			int64_t idx = r_iter;
+			idx += step;
+
+			if (step < 0 && idx <= to)
+				return false;
+
+			if (step > 0 && idx >= to)
+				return false;
+
+			r_iter = idx;
+			return true;
+		} break;
 		case OBJECT: {
 
 			if (!_get_obj().obj) {
@@ -3844,10 +3892,18 @@ Variant Variant::iter_get(const Variant &r_iter, bool &r_valid) const {
 
 			return r_iter;
 		} break;
+		case VECTOR2I: {
+
+			return r_iter;
+		} break;
 		case VECTOR3: {
 
 			return r_iter;
 		} break;
+		case VECTOR3I: {
+
+			return r_iter;
+		} break;
 		case OBJECT: {
 
 			if (!_get_obj().obj) {

modules/gdscript/gdscript_parser.cpp

@@ -3171,9 +3171,9 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 								ConstantNode *cn = alloc_node<ConstantNode>();
 								switch (args.size()) {
-									case 1: cn->value = (int)constants[0]; break;
-									case 2: cn->value = Vector2(constants[0], constants[1]); break;
-									case 3: cn->value = Vector3(constants[0], constants[1], constants[2]); break;
+									case 1: cn->value = (int64_t)constants[0]; break;
+									case 2: cn->value = Vector2i(constants[0], constants[1]); break;
+									case 3: cn->value = Vector3i(constants[0], constants[1], constants[2]); break;
 								}
 								cn->datatype = _type_from_variant(cn->value);
 								container = cn;
@@ -3186,8 +3186,8 @@ void GDScriptParser::_parse_block(BlockNode *p_block, bool p_static) {
 
 								switch (args.size()) {
 									case 1: tn->vtype = Variant::INT; break;
-									case 2: tn->vtype = Variant::VECTOR2; break;
-									case 3: tn->vtype = Variant::VECTOR3; break;
+									case 2: tn->vtype = Variant::VECTOR2I; break;
+									case 3: tn->vtype = Variant::VECTOR3I; break;
 								}
 
 								for (int i = 0; i < args.size(); i++) {
@@ -7802,7 +7802,7 @@ void GDScriptParser::_check_class_level_types(ClassNode *p_class) {
 
 					ConstantNode *tgt_type = alloc_node<ConstantNode>();
 					tgt_type->line = v.line;
-					tgt_type->value = (int)v.data_type.builtin_type;
+					tgt_type->value = (int64_t)v.data_type.builtin_type;
 
 					OperatorNode *convert_call = alloc_node<OperatorNode>();
 					convert_call->line = v.line;
@@ -8179,7 +8179,7 @@ void GDScriptParser::_check_block_types(BlockNode *p_block) {
 
 							ConstantNode *tgt_type = alloc_node<ConstantNode>();
 							tgt_type->line = lv->line;
-							tgt_type->value = (int)lv->datatype.builtin_type;
+							tgt_type->value = (int64_t)lv->datatype.builtin_type;
 							tgt_type->datatype = _type_from_variant(tgt_type->value);
 
 							OperatorNode *convert_call = alloc_node<OperatorNode>();