Fix `do` on `for` loops

core/strings.odin

@@ -14,8 +14,6 @@ new_c_string :: proc(s: string) -> ^u8 {
 
 to_odin_string :: proc(c: ^u8) -> string {
 	len := 0;
-	for (c+len)^ != 0 {
-		len++;
-	}
+	for (c+len)^ != 0 do len++;
 	return string(slice_ptr(c, len));
 }

core/types.odin

@@ -1,5 +1,5 @@
 is_signed :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	match i in type_info_base(info) {
 	case TypeInfo.Integer: return i.signed;
 	case TypeInfo.Float:   return true;
@@ -7,92 +7,92 @@ is_signed :: proc(info: ^TypeInfo) -> bool {
 	return false;
 }
 is_integer :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Integer);
 	return ok;
 }
 is_float :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Float);
 	return ok;
 }
 is_complex :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Complex);
 	return ok;
 }
 is_any :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Any);
 	return ok;
 }
 is_string :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.String);
 	return ok;
 }
 is_boolean :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Boolean);
 	return ok;
 }
 is_pointer :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Pointer);
 	return ok;
 }
 is_procedure :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Procedure);
 	return ok;
 }
 is_array :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Array);
 	return ok;
 }
 is_dynamic_array :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.DynamicArray);
 	return ok;
 }
 is_dynamic_map :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Map);
 	return ok;
 }
 is_slice :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Slice);
 	return ok;
 }
 is_vector :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Vector);
 	return ok;
 }
 is_tuple :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Tuple);
 	return ok;
 }
 is_struct :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Struct);
 	return ok;
 }
 is_union :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Union);
 	return ok;
 }
 is_raw_union :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.RawUnion);
 	return ok;
 }
 is_enum :: proc(info: ^TypeInfo) -> bool {
-	if info == nil { return false; }
+	if info == nil do return false;
 	_, ok := type_info_base(info).(^TypeInfo.Enum);
 	return ok;
 }

core/utf16.odin

@@ -29,11 +29,7 @@ encode_surrogate_pair :: proc(r: rune) -> (r1, r2: rune) {
 
 encode :: proc(d: []u16, s: []rune) {
 	n := len(s);
-	for r in s {
-		if r >= _surr_self {
-			n++;
-		}
-	}
+	for r in s do if r >= _surr_self do n++;
 
 	max_n := min(len(d), n);
 	n = 0;

src/parser.cpp

@@ -3971,7 +3971,8 @@ AstNode *parse_for_stmt(AstFile *f) {
 	AstNode *body = NULL;
 	bool is_range = false;
 
-	if (f->curr_token.kind != Token_OpenBrace) {
+	if (f->curr_token.kind != Token_OpenBrace &&
+	    f->curr_token.kind != Token_do) {
 		isize prev_level = f->expr_level;
 		f->expr_level = -1;
 		if (f->curr_token.kind != Token_Semicolon) {
@@ -3981,8 +3982,7 @@ AstNode *parse_for_stmt(AstFile *f) {
 			}
 		}
 
-		if (!is_range && (f->curr_token.kind == Token_Semicolon ||
-		                  f->curr_token.kind == Token_do)) {
+		if (!is_range && f->curr_token.kind == Token_Semicolon) {
 			next_token(f);
 			init = cond;
 			cond = NULL;