Ellipsis is now just `..`; Remove half-closed range operator and treat all of them as half-closed; slice expression uses `..`;

code/demo.odin

@@ -9,14 +9,14 @@
 
 main :: proc() {
 	buf: [64]byte;
-	// len := strconv.generic_ftoa(buf[:], 123.5431, 'f', 4, 64);
+	// len := strconv.generic_ftoa(buf[..], 123.5431, 'f', 4, 64);
 	x := 624.123;
-	s := strconv.format_float(buf[:], x, 'f', 6, 64);
+	s := strconv.format_float(buf[..], x, 'f', 6, 64);
 	fmt.println(s);
 	fmt.printf("%3d\n", 102);
 
-	i := 123;
-	fmt.println(123);
+	a := [..]int{0, 1, 2, 3, 4, 5, 6};
+	fmt.println(a[0..4]);
 
 
 when false {

core/_preload.odin

@@ -316,7 +316,7 @@ __bounds_check_error :: proc(file: string, line, column: int, index, count: int)
 	if 0 <= index && index < count {
 		return;
 	}
-	fmt.fprintf(os.stderr, "%s(%d:%d) Index %d is out of bounds range 0..<%d\n",
+	fmt.fprintf(os.stderr, "%s(%d:%d) Index %d is out of bounds range 0..%d\n",
 	            file, line, column, index, count);
 	__debug_trap();
 }
@@ -325,7 +325,7 @@ __slice_expr_error :: proc(file: string, line, column: int, low, high: int) {
 	if 0 <= low && low <= high {
 		return;
 	}
-	fmt.fprintf(os.stderr, "%s(%d:%d) Invalid slice indices: [%d:%d]\n",
+	fmt.fprintf(os.stderr, "%s(%d:%d) Invalid slice indices: [%d..%d]\n",
 	            file, line, column, low, high);
 	__debug_trap();
 }
@@ -333,7 +333,7 @@ __substring_expr_error :: proc(file: string, line, column: int, low, high: int)
 	if 0 <= low && low <= high {
 		return;
 	}
-	fmt.fprintf(os.stderr, "%s(%d:%d) Invalid substring indices: [%d:%d]\n",
+	fmt.fprintf(os.stderr, "%s(%d:%d) Invalid substring indices: [%d..%d]\n",
 	            file, line, column, low, high);
 	__debug_trap();
 }

core/decimal.odin

@@ -3,11 +3,10 @@
 // NOTE: This is only for floating point printing and nothing else
 
 Decimal :: struct {
-	d:     [384]byte, // big-endian digits
-	ndu:   int,
-	dp:    int,
-	neg:   bool,
-	trunc: bool,
+	digits:        [384]byte, // big-endian digits
+	count:         int,
+	decimal_point: int,
+	neg, trunc:    bool,
 }
 
 decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string {
@@ -19,42 +18,42 @@ decimal_to_string :: proc(buf: []byte, a: ^Decimal) -> string {
 	}
 
 
-	n := 10 + a.ndu + abs(a.dp);
+	n := 10 + a.count + abs(a.decimal_point);
 
 	// TODO(bill): make this work with a buffer that's not big enough
 	assert(buf.count >= n);
-	buf = buf[:n];
+	buf = buf[..n];
 
-	if a.ndu == 0 {
+	if a.count == 0 {
 		buf[0] = '0';
-		return cast(string)buf[0:1];
+		return cast(string)buf[0..1];
 	}
 
 	w := 0;
-	if a.dp <= 0 {
+	if a.decimal_point <= 0 {
 		buf[w] = '0'; w++;
 		buf[w] = '.'; w++;
-		w += digit_zero(buf[w: w-a.dp]);
-		w += copy(buf[w:], a.d[0:a.ndu]);
-	} else if a.dp < a.ndu {
-		w += copy(buf[w:], a.d[0:a.dp]);
+		w += digit_zero(buf[w .. w-a.decimal_point]);
+		w += copy(buf[w..], a.digits[0..a.count]);
+	} else if a.decimal_point < a.count {
+		w += copy(buf[w..], a.digits[0..a.decimal_point]);
 		buf[w] = '.'; w++;
-		w += copy(buf[w:], a.d[a.dp:a.ndu]);
+		w += copy(buf[w..], a.digits[a.decimal_point .. a.count]);
 	} else {
-		w += copy(buf[w:], a.d[0:a.ndu]);
-		w += digit_zero(buf[w : w+a.dp-a.ndu]);
+		w += copy(buf[w..], a.digits[0..a.count]);
+		w += digit_zero(buf[w .. w+a.decimal_point-a.count]);
 	}
 
-	return cast(string)buf[0:w];
+	return cast(string)buf[0..w];
 }
 
 // trim trailing zeros
 trim :: proc(a: ^Decimal) {
-	for a.ndu > 0 && a.d[a.ndu-1] == '0' {
-		a.ndu--;
+	for a.count > 0 && a.digits[a.count-1] == '0' {
+		a.count--;
 	}
-	if a.ndu == 0 {
-		a.dp = 0;
+	if a.count == 0 {
+		a.decimal_point = 0;
 	}
 }
 
@@ -70,12 +69,12 @@ assign :: proc(a: ^Decimal, i: u64) {
 		i = j;
 	}
 
-	a.ndu = 0;
+	a.count = 0;
 	for n--; n >= 0; n-- {
-		a.d[a.ndu] = buf[n];
-		a.ndu++;
+		a.digits[a.count] = buf[n];
+		a.count++;
 	}
-	a.dp = a.ndu;
+	a.decimal_point = a.count;
 	trim(a);
 }
 
@@ -88,10 +87,10 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 
 	n: uint;
 	for ; n>>k == 0; r++ {
-		if r >= a.ndu {
+		if r >= a.count {
 			if n == 0 {
 				// Just in case
-				a.ndu = 0;
+				a.count = 0;
 				return;
 			}
 			for n>>k == 0 {
@@ -100,18 +99,18 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 			}
 			break;
 		}
-		c := cast(uint)a.d[r];
+		c := cast(uint)a.digits[r];
 		n = n*10 + c - '0';
 	}
-	a.dp -= r-1;
+	a.decimal_point -= r-1;
 
 	mask: uint = (1<<k) - 1;
 
-	for ; r < a.ndu; r++ {
-		c := cast(uint)a.d[r];
+	for ; r < a.count; r++ {
+		c := cast(uint)a.digits[r];
 		dig := n>>k;
 		n &= mask;
-		a.d[w] = cast(byte)('0' + dig);
+		a.digits[w] = cast(byte)('0' + dig);
 		w++;
 		n = n*10 + c - '0';
 	}
@@ -119,8 +118,8 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 	for n > 0 {
 		dig := n>>k;
 		n &= mask;
-		if w < a.d.count {
-			a.d[w] = cast(byte)('0' + dig);
+		if w < a.digits.count {
+			a.digits[w] = cast(byte)('0' + dig);
 			w++;
 		} else if dig > 0 {
 			a.trunc = true;
@@ -129,24 +128,24 @@ shift_right :: proc(a: ^Decimal, k: uint) {
 	}
 
 
-	a.ndu = w;
+	a.count = w;
 	trim(a);
 }
 
 shift_left :: proc(a: ^Decimal, k: uint) {
 	delta := cast(int)(k/4);
 
-	r := a.ndu;       // read index
-	w := a.ndu+delta; // write index
+	r := a.count;       // read index
+	w := a.count+delta; // write index
 
 	n: uint;
 	for r--; r >= 0; r-- {
-		n += (cast(uint)a.d[r] - '0') << k;
+		n += (cast(uint)a.digits[r] - '0') << k;
 		quo := n/10;
 		rem := n - 10*quo;
 		w--;
-		if w < a.d.count {
-			a.d[w] = cast(byte)('0' + rem);
+		if w < a.digits.count {
+			a.digits[w] = cast(byte)('0' + rem);
 		} else if rem != 0 {
 			a.trunc = true;
 		}
@@ -157,23 +156,23 @@ shift_left :: proc(a: ^Decimal, k: uint) {
 		quo := n/10;
 		rem := n - 10*quo;
 		w--;
-		if w < a.d.count {
-			a.d[w] = cast(byte)('0' + rem);
+		if w < a.digits.count {
+			a.digits[w] = cast(byte)('0' + rem);
 		} else if rem != 0 {
 			a.trunc = true;
 		}
 		n = quo;
 	}
 
-	a.ndu += delta;
-	a.ndu = min(a.ndu, a.d.count);
-	a.dp += delta;
+	a.count += delta;
+	a.count = min(a.count, a.digits.count);
+	a.decimal_point += delta;
 	trim(a);
 }
 
 shift :: proc(a: ^Decimal, k: int) {
 	match {
-	case a.ndu == 0:
+	case a.count == 0:
 		// no need to update
 	case k > 0:
 		for k > max_shift {
@@ -193,19 +192,19 @@ shift :: proc(a: ^Decimal, k: int) {
 }
 
 can_round_up :: proc(a: ^Decimal, nd: int) -> bool {
-	if nd < 0 || nd >= a.ndu { return false ; }
-	if a.d[nd] == '5' && nd+1 == a.ndu {
+	if nd < 0 || nd >= a.count { return false ; }
+	if a.digits[nd] == '5' && nd+1 == a.count {
 		if a.trunc {
 			return true;
 		}
-		return nd > 0 && (a.d[nd-1]-'0')%2 != 0;
+		return nd > 0 && (a.digits[nd-1]-'0')%2 != 0;
 	}
 
-	return a.d[nd] >= '5';
+	return a.digits[nd] >= '5';
 }
 
 round :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.ndu { return; }
+	if nd < 0 || nd >= a.count { return; }
 	if can_round_up(a, nd) {
 		round_up(a, nd);
 	} else {
@@ -214,44 +213,44 @@ round :: proc(a: ^Decimal, nd: int) {
 }
 
 round_up :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.ndu { return; }
+	if nd < 0 || nd >= a.count { return; }
 
 	for i := nd-1; i >= 0; i-- {
-		if c := a.d[i]; c < '9' {
-			a.d[i]++;
-			a.ndu = i+1;
+		if c := a.digits[i]; c < '9' {
+			a.digits[i]++;
+			a.count = i+1;
 			return;
 		}
 	}
 
 	// Number is just 9s
-	a.d[0] = '1';
-	a.ndu = 1;
-	a.dp++;
+	a.digits[0] = '1';
+	a.count = 1;
+	a.decimal_point++;
 }
 
 round_down :: proc(a: ^Decimal, nd: int) {
-	if nd < 0 || nd >= a.ndu { return; }
-	a.ndu = nd;
+	if nd < 0 || nd >= a.count { return; }
+	a.count = nd;
 	trim(a);
 }
 
 
 // Extract integer part, rounded appropriately. There are no guarantees about overflow.
 rounded_integer :: proc(a: ^Decimal) -> u64 {
-	if a.dp > 20 {
+	if a.decimal_point > 20 {
 		return 0xffff_ffff_ffff_ffff;
 	}
 	i: int;
 	n: u64 = 0;
-	m := min(a.dp, a.ndu);
+	m := min(a.decimal_point, a.count);
 	for i = 0; i < m; i++ {
-		n = n*10 + cast(u64)(a.d[i]-'0');
+		n = n*10 + cast(u64)(a.digits[i]-'0');
 	}
-	for ; i < a.dp; i++ {
+	for ; i < a.decimal_point; i++ {
 		n *= 10;
 	}
-	if can_round_up(a, a.dp) {
+	if can_round_up(a, a.decimal_point) {
 		n++;
 	}
 	return n;

core/fmt.odin

@@ -16,7 +16,7 @@ buffer_write :: proc(buf: ^Buffer, b: []byte) {
 	if buf.length < buf.data.count {
 		n := min(buf.data.count-buf.length, b.count);
 		if n > 0 {
-			copy(buf.data[buf.length:], b[:n]);
+			copy(buf.data[buf.length..], b[..n]);
 			buf.length += n;
 		}
 	}
@@ -37,7 +37,7 @@ buffer_write_rune :: proc(buf: ^Buffer, r: rune) {
 	}
 
 	b, n := utf8.encode_rune(r);
-	buffer_write(buf, b[:n]);
+	buffer_write(buf, b[..n]);
 }
 
 Fmt_Info :: struct {
@@ -61,46 +61,46 @@ Fmt_Info :: struct {
 
 
 
-fprint :: proc(fd: os.Handle, args: ...any) -> int {
+fprint :: proc(fd: os.Handle, args: ..any) -> int {
 	data: [_BUFFER_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprint(^buf, ...args);
-	os.write(fd, buf.data[:buf.length]);
+	buf := Buffer{data[..], 0};
+	bprint(^buf, ..args);
+	os.write(fd, buf.data[..buf.length]);
 	return buf.length;
 }
 
-fprintln :: proc(fd: os.Handle, args: ...any) -> int {
+fprintln :: proc(fd: os.Handle, args: ..any) -> int {
 	data: [_BUFFER_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprintln(^buf, ...args);
-	os.write(fd, buf.data[:buf.length]);
+	buf := Buffer{data[..], 0};
+	bprintln(^buf, ..args);
+	os.write(fd, buf.data[..buf.length]);
 	return buf.length;
 }
-fprintf :: proc(fd: os.Handle, fmt: string, args: ...any) -> int {
+fprintf :: proc(fd: os.Handle, fmt: string, args: ..any) -> int {
 	data: [_BUFFER_SIZE]byte;
-	buf := Buffer{data[:], 0};
-	bprintf(^buf, fmt, ...args);
-	os.write(fd, buf.data[:buf.length]);
+	buf := Buffer{data[..], 0};
+	bprintf(^buf, fmt, ..args);
+	os.write(fd, buf.data[..buf.length]);
 	return buf.length;
 }
 
 
-print :: proc(args: ...any) -> int {
-	return fprint(os.stdout, ...args);
+print :: proc(args: ..any) -> int {
+	return fprint(os.stdout, ..args);
 }
-println :: proc(args: ...any) -> int {
-	return fprintln(os.stdout, ...args);
+println :: proc(args: ..any) -> int {
+	return fprintln(os.stdout, ..args);
 }
-printf :: proc(fmt: string, args: ...any) -> int {
-	return fprintf(os.stdout, fmt, ...args);
+printf :: proc(fmt: string, args: ..any) -> int {
+	return fprintf(os.stdout, fmt, ..args);
 }
 
 
 fprint_type :: proc(fd: os.Handle, info: ^Type_Info) {
 	data: [_BUFFER_SIZE]byte;
-	buf := Buffer{data[:], 0};
+	buf := Buffer{data[..], 0};
 	buffer_write_type(^buf, info);
-	os.write(fd, buf.data[:buf.length]);
+	os.write(fd, buf.data[..buf.length]);
 }
 
 buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
@@ -176,7 +176,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
 		buffer_write_string(buf, "]");
 		buffer_write_type(buf, info.elem);
 	case Dynamic_Array:
-		buffer_write_string(buf, "[...]");
+		buffer_write_string(buf, "[..]");
 		buffer_write_type(buf, info.elem);
 	case Slice:
 		buffer_write_string(buf, "[");
@@ -241,7 +241,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
 			variant := union_cast(^Struct)variant_type;
 
 			vc := variant.names.count-cf.names.count;
-			for j in 0..<vc {
+			for j in 0..vc {
 				if j > 0 {
 					buffer_write_string(buf, ", ");
 				}
@@ -280,7 +280,7 @@ buffer_write_type :: proc(buf: ^Buffer, ti: ^Type_Info) {
 }
 
 
-bprint :: proc(buf: ^Buffer, args: ...any) -> int {
+bprint :: proc(buf: ^Buffer, args: ..any) -> int {
 	fi: Fmt_Info;
 	fi.buf = buf;
 
@@ -296,7 +296,7 @@ bprint :: proc(buf: ^Buffer, args: ...any) -> int {
 	return buf.length;
 }
 
-bprintln :: proc(buf: ^Buffer, args: ...any) -> int {
+bprintln :: proc(buf: ^Buffer, args: ..any) -> int {
 	fi: Fmt_Info;
 	fi.buf = buf;
 
@@ -310,23 +310,23 @@ bprintln :: proc(buf: ^Buffer, args: ...any) -> int {
 	return buf.length;
 }
 
-sprint :: proc(buf: []byte, args: ...any) -> string {
+sprint :: proc(buf: []byte, args: ..any) -> string {
 	b: Buffer;
 	b.data = buf;
-	count := bprint(^b, ...args);
-	return cast(string)b.data[:b.length];
+	count := bprint(^b, ..args);
+	return cast(string)b.data[..b.length];
 }
-sprintln :: proc(buf: []byte, args: ...any) -> string {
+sprintln :: proc(buf: []byte, args: ..any) -> string {
 	b: Buffer;
 	b.data = buf;
-	count := bprintln(^b, ...args);
-	return cast(string)b.data[:b.length];
+	count := bprintln(^b, ..args);
+	return cast(string)b.data[..b.length];
 }
-sprintf :: proc(buf: []byte, fmt: string, args: ...any) -> string {
+sprintf :: proc(buf: []byte, fmt: string, args: ..any) -> string {
 	b: Buffer;
 	b.data = buf;
-	count := bprintf(^b, fmt, ...args);
-	return cast(string)b.data[:b.length];
+	count := bprintf(^b, fmt, ..args);
+	return cast(string)b.data[..b.length];
 }
 
 
@@ -341,7 +341,7 @@ parse_int :: proc(s: string, offset: int) -> (result: int, offset: int, ok: bool
 	ok := true;
 
 	i := 0;
-	for o in offset..<s.count {
+	for o in offset..s.count {
 		c := cast(rune)s[offset+i];
 		if !is_digit(c) {
 			break;
@@ -366,7 +366,7 @@ _arg_number :: proc(fi: ^Fmt_Info,
 			return 0, 1, false;
 		}
 
-		for i in 1..<format.count {
+		for i in 1..format.count {
 			if format[i] == ']' {
 				width, new_index, ok := parse_int(format, 1);
 				if !ok || new_index != i {
@@ -384,7 +384,7 @@ _arg_number :: proc(fi: ^Fmt_Info,
 		return arg_index, offset, false;
 	}
 	fi.reordered = true;
-	index, width, ok := parse_arg_number(format[offset:]);
+	index, width, ok := parse_arg_number(format[offset..]);
 	if ok && 0 <= index && index < arg_count {
 		return index, offset+width, true;
 	}
@@ -454,7 +454,7 @@ fmt_write_padding :: proc(fi: ^Fmt_Info, width: int) {
 
 	count := min(width, fi.buf.data.count-fi.buf.length);
 	start := fi.buf.length;
-	for i in start..<count {
+	for i in start..count {
 		fi.buf.data[i] = pad_byte;
 	}
 	fi.buf.length += count;
@@ -503,11 +503,11 @@ _write_int :: proc(fi: ^Fmt_Info, u: u64, base: int, neg: bool, digits: string)
 	if fi.hash  { flags |= strconv.Int_Flag.PREFIX; }
 	if fi.plus  { flags |= strconv.Int_Flag.PLUS; }
 	if fi.space { flags |= strconv.Int_Flag.SPACE; }
-	s := strconv.format_bits(buf[:], u, base, neg, digits, flags);
+	s := strconv.format_bits(buf[..], u, base, neg, digits, flags);
 
 	prev_zero := fi.zero;
-	fi.zero = false;
 	defer fi.zero = prev_zero;
+	fi.zero = false;
 	_pad(fi, s);
 }
 
@@ -570,10 +570,10 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {
 			prec = fi.prec;
 		}
 		buf: [128]byte;
-		str := strconv.format_float(buf[1:], v, 'f', prec, bit_size);
-		str = cast(string)buf[:str.count+1];
+		str := strconv.format_float(buf[1..], v, 'f', prec, bit_size);
+		str = cast(string)buf[..str.count+1];
 		if str[1] == '+' || str[1] == '-' {
-			str = str[1:];
+			str = str[1..];
 		} else {
 			str[0] = '+';
 		}
@@ -591,12 +591,12 @@ fmt_float :: proc(fi: ^Fmt_Info, v: f64, bit_size: int, verb: rune) {
 			if fi.zero && fi.width_set && fi.width > str.count {
 				buffer_write_byte(fi.buf, str[0]);
 				fmt_write_padding(fi, fi.width - str.count);
-				buffer_write_string(fi.buf, str[1:]);
+				buffer_write_string(fi.buf, str[1..]);
 			} else {
 				_pad(fi, str);
 			}
 		} else {
-			_pad(fi, str[1:]);
+			_pad(fi, str[1..]);
 		}
 
 	default:
@@ -747,7 +747,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 
 		buffer_write_byte(fi.buf, '[');
 		defer buffer_write_byte(fi.buf, ']');
-		for i in 0..<info.count {
+		for i in 0..info.count {
 			if i > 0 {
 				buffer_write_string(fi.buf, ", ");
 			}
@@ -764,7 +764,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 		buffer_write_byte(fi.buf, '[');
 		defer buffer_write_byte(fi.buf, ']');
 		array := cast(^Raw_Dynamic_Array)v.data;
-		for i in 0..<array.count {
+		for i in 0..array.count {
 			if i > 0 {
 				buffer_write_string(fi.buf, ", ");
 			}
@@ -786,7 +786,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 
 		entry_type := union_cast(^Struct)ed.elem;
 		entry_size := ed.elem_size;
-		for i in 0..<entries.count {
+		for i in 0..entries.count {
 			if i > 0 {
 				buffer_write_string(fi.buf, ", ");
 			}
@@ -815,7 +815,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 		buffer_write_byte(fi.buf, '[');
 		defer buffer_write_byte(fi.buf, ']');
 		slice := cast(^[]byte)v.data;
-		for i in 0..<slice.count {
+		for i in 0..slice.count {
 			if i > 0 {
 				buffer_write_string(fi.buf, ", ");
 			}
@@ -827,7 +827,7 @@ fmt_value :: proc(fi: ^Fmt_Info, v: any, verb: rune) {
 		buffer_write_byte(fi.buf, '<');
 		defer buffer_write_byte(fi.buf, '>');
 
-		for i in 0..<info.count {
+		for i in 0..info.count {
 			if i > 0 {
 				buffer_write_string(fi.buf, ", ");
 			}
@@ -920,7 +920,7 @@ fmt_arg :: proc(fi: ^Fmt_Info, arg: any, verb: rune) {
 }
 
 
-bprintf :: proc(b: ^Buffer, fmt: string, args: ...any) -> int {
+bprintf :: proc(b: ^Buffer, fmt: string, args: ..any) -> int {
 	fi := Fmt_Info{};
 	end := fmt.count;
 	arg_index := 0;
@@ -933,7 +933,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ...any) -> int {
 			i++;
 		}
 		if i > prev_i {
-			buffer_write_string(b, fmt[prev_i:i]);
+			buffer_write_string(b, fmt[prev_i..i]);
 		}
 		if i >= end {
 			break;
@@ -1026,7 +1026,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ...any) -> int {
 			break;
 		}
 
-		verb, w := utf8.decode_rune(fmt[i:]);
+		verb, w := utf8.decode_rune(fmt[i..]);
 		i += w;
 
 		if verb == '%' {
@@ -1043,7 +1043,7 @@ bprintf :: proc(b: ^Buffer, fmt: string, args: ...any) -> int {
 
 	if !fi.reordered && arg_index < args.count {
 		buffer_write_string(b, "%!(EXTRA ");
-		for arg, index in args[arg_index:] {
+		for arg, index in args[arg_index..] {
 			if index > 0 {
 				buffer_write_string(b, ", ");
 			}

core/hash.odin

@@ -66,7 +66,7 @@ murmur32 :: proc(data: []byte) -> u32 {
 		h1 = h1*5 + 0xe6546b64;
 	}
 
-	tail := data[nblocks*4:];
+	tail := data[nblocks*4 ..];
 
 	k1: u32;
 	match tail.count&3 {
@@ -174,7 +174,7 @@ murmur64 :: proc(data: []byte) -> u64 {
 			len -= 4;
 		}
 
-		data8 := slice_to_bytes(data32[i:])[:3];
+		data8 := slice_to_bytes(data32[i..])[..3];
 		match len {
 		case 3:
 			h2 ~= cast(u32)data8[2] << 16;

core/math.odin

@@ -151,8 +151,8 @@ mat4_identity :: proc() -> Mat4 {
 }
 
 mat4_transpose :: proc(m: Mat4) -> Mat4 {
-	for j in 0..<4 {
-		for i in 0..<4 {
+	for j in 0..4 {
+		for i in 0..4 {
 			m[i][j], m[j][i] = m[j][i], m[i][j];
 		}
 	}
@@ -161,8 +161,8 @@ mat4_transpose :: proc(m: Mat4) -> Mat4 {
 
 mul :: proc(a, b: Mat4) -> Mat4 {
 	c: Mat4;
-	for j in 0..<4 {
-		for i in 0..<4 {
+	for j in 0..4 {
+		for i in 0..4 {
 			c[j][i] = a[0][i]*b[j][0] +
 			          a[1][i]*b[j][1] +
 			          a[2][i]*b[j][2] +

core/mem.odin

@@ -32,7 +32,7 @@ copy_non_overlapping :: proc(dst, src: rawptr, len: int) -> rawptr #link_name "_
 
 compare :: proc(a, b: []byte) -> int #link_name "__mem_compare" {
 	n := min(a.count, b.count);
-	for i in 0..<n {
+	for i in 0..n {
 		match {
 		case a[i] < b[i]:
 			return -1;
@@ -117,7 +117,7 @@ Arena_Temp_Memory :: struct {
 
 init_arena_from_memory :: proc(using a: ^Arena, data: []byte) {
 	backing    = Allocator{};
-	memory     = data[:0];
+	memory     = data[..0];
 	temp_count = 0;
 }
 

core/os_windows.odin

@@ -95,7 +95,7 @@ open :: proc(path: string, mode: int, perm: u32) -> (Handle, Errno) {
 	}
 
 	buf: [300]byte;
-	copy(buf[:], cast([]byte)path);
+	copy(buf[..], cast([]byte)path);
 
 	handle := cast(Handle)CreateFileA(^buf[0], access, share_mode, sa, create_mode, FILE_ATTRIBUTE_NORMAL, nil);
 	if handle != INVALID_HANDLE {
@@ -184,7 +184,7 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
 
 	assert(buf.count > name.count);
 
-	copy(buf[:], cast([]byte)name);
+	copy(buf[..], cast([]byte)name);
 
 	if win32.GetFileAttributesExA(^buf[0], win32.GetFileExInfoStandard, ^data) != 0 {
 		last_write_time = data.last_write_time;
@@ -201,7 +201,7 @@ last_write_time_by_name :: proc(name: string) -> File_Time {
 
 read_entire_file :: proc(name: string) -> ([]byte, bool) {
 	buf: [300]byte;
-	copy(buf[:], cast([]byte)name);
+	copy(buf[..], cast([]byte)name);
 
 	fd, err := open(name, O_RDONLY, 0);
 	if err != ERROR_NONE {

core/strconv.odin

@@ -1,6 +1,5 @@
 #import . "decimal.odin";
 #import "math.odin";
-#import format "fmt.odin";
 
 Int_Flag :: enum {
 	PREFIX = 1<<0,
@@ -22,7 +21,7 @@ parse_bool :: proc(s: string) -> (result: bool, ok: bool) {
 format_bool :: proc(buf: []byte, b: bool) -> string {
 	s := b ? "true" : "false";
 	len := copy(buf, cast([]byte)s);
-	return cast(string)buf[:len];
+	return cast(string)buf[..len];
 }
 
 format_uint :: proc(buf: []byte, u: u64, base: int) -> string {
@@ -44,10 +43,10 @@ format_float :: proc(buf: []byte, f: f64, fmt: byte, prec, bit_size: int) -> str
 
 
 Decimal_Slice :: struct {
-	d:   []byte,
-	ndu: int,
-	dp:  int,
-	neg: bool,
+	digits:        []byte,
+	count:         int,
+	decimal_point: int,
+	neg:           bool,
 }
 
 Float_Info :: struct {
@@ -89,7 +88,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
 			s = "+Inf";
 		}
 		len := copy(buf, cast([]byte)s);
-		return buf[:len];
+		return buf[..len];
 
 	case 0: // denormalized
 		exp++;
@@ -108,19 +107,19 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
 	shortest := prec < 0;
 	if shortest {
 		round_shortest(d, mant, exp, flt);
-		digs = Decimal_Slice{d = d.d[:], ndu = d.ndu, dp = d.dp};
+		digs = Decimal_Slice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
 		match fmt {
 		case 'e', 'E':
-			prec = digs.ndu-1;
+			prec = digs.count-1;
 		case 'f', 'F':
-			prec = max(digs.ndu-digs.dp, 0);
+			prec = max(digs.count-digs.decimal_point, 0);
 		case 'g', 'G':
-			prec = digs.ndu;
+			prec = digs.count;
 		}
 	} else {
 		match fmt {
 		case 'e', 'E': round(d, prec+1);
-		case 'f', 'F': round(d, d.dp+prec);
+		case 'f', 'F': round(d, d.decimal_point+prec);
 		case 'g', 'G':
 			if prec == 0 {
 				prec = 1;
@@ -128,7 +127,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
 			round(d, prec);
 		}
 
-		digs = Decimal_Slice{d = d.d[:], ndu = d.ndu, dp = d.dp};
+		digs = Decimal_Slice{digits = d.digits[..], count = d.count, decimal_point = d.decimal_point};
 	}
 	return format_digits(buf, shortest, neg, digs, prec, fmt);
 }
@@ -138,7 +137,7 @@ generic_ftoa :: proc(buf: []byte, val: f64, fmt: byte, prec, bit_size: int) -> [
 format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slice, prec: int, fmt: byte) -> []byte {
 	match fmt {
 	case 'f', 'F':
-		add_bytes :: proc(dst: ^[]byte, w: ^int, bytes: ...byte) {
+		add_bytes :: proc(dst: ^[]byte, w: ^int, bytes: ..byte) {
 			for b in bytes {
 				if dst.count <= w^ {
 					break;
@@ -148,7 +147,7 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic
 			}
 		}
 
-		dst := buf[:];
+		dst := buf[..];
 		w := 0;
 		if neg {
 			add_bytes(^dst, ^w, '-');
@@ -157,10 +156,10 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic
 		}
 
 		// integer, padded with zeros when needed
-		if digs.dp > 0 {
-			m := min(digs.ndu, digs.dp);
-			add_bytes(^dst, ^w, ...digs.d[:m]);
-			for ; m < digs.dp; m++ {
+		if digs.decimal_point > 0 {
+			m := min(digs.count, digs.decimal_point);
+			add_bytes(^dst, ^w, ..digs.digits[..m]);
+			for ; m < digs.decimal_point; m++ {
 				add_bytes(^dst, ^w, '0');
 			}
 		} else {
@@ -170,16 +169,16 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic
 		// fractional part
 		if prec > 0 {
 			add_bytes(^dst, ^w, '.');
-			for i in 0..<prec {
+			for i in 0..prec {
 				c: byte = '0';
-				if j := digs.dp + i; 0 <= j && j < digs.ndu {
-					c = digs.d[j];
+				if j := digs.decimal_point + i; 0 <= j && j < digs.count {
+					c = digs.digits[j];
 				}
 				add_bytes(^dst, ^w, c);
 			}
 		}
 
-		return buf[:w];
+		return buf[..w];
 
 	case 'e', 'E':
 		return nil; // TODO
@@ -191,13 +190,13 @@ format_digits :: proc(buf: []byte, shortest: bool, neg: bool, digs: Decimal_Slic
 	c: [2]byte;
 	c[0] = '%';
 	c[1] = fmt;
-	len := copy(buf, ...c[:]);
-	return buf[:len];
+	len := copy(buf, ..c[..]);
+	return buf[..len];
 }
 
 round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 	if mant == 0 { // If mantissa is zero, the number is zero
-		d.ndu = 0;
+		d.count = 0;
 		return;
 	}
 
@@ -208,7 +207,7 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 		332*(dp-nd) >= 100*(exp-mantbits)
 	 */
 	minexp := flt.bias+1;
-	if exp > minexp && 332*(d.dp-d.ndu) >= 100*(exp - cast(int)flt.mantbits) {
+	if exp > minexp && 332*(d.decimal_point-d.count) >= 100*(exp - cast(int)flt.mantbits) {
 		// Number is already its shortest
 		return;
 	}
@@ -232,19 +231,19 @@ round_shortest :: proc(d: ^Decimal, mant: u64, exp: int, flt: ^Float_Info) {
 
 	inclusive := mant%2 == 0;
 
-	for i in 0..<d.ndu {
+	for i in 0..d.count {
 		l: byte = '0'; // lower digit
-		if i < lower.ndu {
-			l = lower.d[i];
+		if i < lower.count {
+			l = lower.digits[i];
 		}
-		m := d.d[i];   // middle digit
+		m := d.digits[i];   // middle digit
 		u: byte = '0'; // upper digit
-		if i < upper.ndu {
-			u = upper.d[i];
+		if i < upper.count {
+			u = upper.digits[i];
 		}
 
-		ok_round_down := l != m || inclusive && i+1 == lower.ndu;
-		ok_round_up   := m != u && (inclusive || m+1 < u || i+1 < upper.ndu);
+		ok_round_down := l != m || inclusive && i+1 == lower.count;
+		ok_round_up   := m != u && (inclusive || m+1 < u || i+1 < upper.count);
 
 		if (ok_round_down && ok_round_up) {
 			round(d, i+1);
@@ -331,7 +330,7 @@ format_bits :: proc(buf: []byte, u: u64, base: int, neg: bool, digits: string, f
 	}
 
 
-	len := copy(buf, ...a[i:]);
-	return cast(string)buf[:len];
+	len := copy(buf, ..a[i..]);
+	return cast(string)buf[..len];
 }
 

core/utf8.odin

@@ -160,7 +160,7 @@ decode_last_rune :: proc(s: []byte) -> (rune, int) {
 	}
 
 	start = max(start, 0);
-	r, size = decode_rune(s[start:end]);
+	r, size = decode_rune(s[start..end]);
 	if start+size != end {
 		return RUNE_ERROR, 1;
 	}

src/check_stmt.c

@@ -715,8 +715,7 @@ void check_stmt_internal(Checker *c, AstNode *node, u32 flags) {
 
 				TokenKind op = Token_Lt;
 				switch (ie->op.kind) {
-				case Token_HalfOpenRange: op = Token_Lt;   break;
-				case Token_Ellipsis:      op = Token_LtEq; break;
+				case Token_Ellipsis: op = Token_Lt; break;
 				default: error(ie->op, "Invalid range operator"); break;
 				}
 				bool ok = compare_exact_values(Token_Lt, a, b);

src/ir.c

@@ -4742,8 +4742,7 @@ void ir_build_range_interval(irProcedure *proc, AstNodeIntervalExpr *node, Type
 
 	TokenKind op = Token_Lt;
 	switch (node->op.kind) {
-	case Token_HalfOpenRange: op = Token_Lt;   break;
-	case Token_Ellipsis:      op = Token_LtEq; break;
+	case Token_Ellipsis: op = Token_Lt; break;
 	default: GB_PANIC("Invalid interval operator"); break;
 	}
 	irValue *cond = ir_emit_comp(proc, op, ir_emit_load(proc, value), upper);

src/parser.c

@@ -1950,16 +1950,12 @@ AstNode *parse_atom_expr(AstFile *f, bool lhs) {
 			f->expr_level++;
 			open = expect_token(f, Token_OpenBracket);
 
-			// if (f->curr_token.kind != Token_Ellipsis &&
-			    // f->curr_token.kind != Token_HalfOpenRange) {
-			if (f->curr_token.kind != Token_Colon) {
+			if (f->curr_token.kind != Token_Ellipsis) {
 				indices[0] = parse_expr(f, false);
 			}
 			bool is_index = true;
 
-			// if (f->curr_token.kind == Token_Ellipsis ||
-			    // f->curr_token.kind == Token_HalfOpenRange) {
-			if (f->curr_token.kind == Token_Colon) {
+			if (f->curr_token.kind == Token_Ellipsis) {
 				is_index = false;
 				interval = f->curr_token;
 				next_token(f);
@@ -2261,7 +2257,6 @@ AstNode *parse_simple_stmt(AstFile *f, bool in_stmt_ok) {
 			allow_token(f, Token_in);
 			AstNode *expr = parse_expr(f, false);
 			switch (f->curr_token.kind) {
-			case Token_HalfOpenRange:
 			case Token_Ellipsis: {
 				Token op = f->curr_token;
 				next_token(f);

src/tokenizer.c

@@ -73,8 +73,8 @@ TOKEN_KIND(Token__ComparisonEnd, "_ComparisonEnd"), \
 	TOKEN_KIND(Token_Semicolon,     ";"), \
 	TOKEN_KIND(Token_Period,        "."), \
 	TOKEN_KIND(Token_Comma,         ","), \
-	TOKEN_KIND(Token_Ellipsis,      "..."), \
-	TOKEN_KIND(Token_HalfOpenRange, "..<"), \
+	TOKEN_KIND(Token_Ellipsis,      ".."), \
+	/* TOKEN_KIND(Token_HalfOpenRange, "..<"), */ \
 TOKEN_KIND(Token__OperatorEnd, "_OperatorEnd"), \
 \
 TOKEN_KIND(Token__KeywordBegin, "_KeywordBegin"), \
@@ -225,6 +225,23 @@ void syntax_error_va(Token token, char *fmt, va_list va) {
 	gb_mutex_unlock(&global_error_collector.mutex);
 }
 
+void syntax_warning_va(Token token, char *fmt, va_list va) {
+	gb_mutex_lock(&global_error_collector.mutex);
+	global_error_collector.warning_count++;
+	// NOTE(bill): Duplicate error, skip it
+	if (!token_pos_eq(global_error_collector.prev, token.pos)) {
+		global_error_collector.prev = token.pos;
+		gb_printf_err("%.*s(%td:%td) Syntax Warning: %s\n",
+		              LIT(token.pos.file), token.pos.line, token.pos.column,
+		              gb_bprintf_va(fmt, va));
+	} else if (token.pos.line == 0) {
+		gb_printf_err("Warning: %s\n", gb_bprintf_va(fmt, va));
+	}
+
+	gb_mutex_unlock(&global_error_collector.mutex);
+}
+
+
 
 void warning(Token token, char *fmt, ...) {
 	va_list va;
@@ -247,6 +264,13 @@ void syntax_error(Token token, char *fmt, ...) {
 	va_end(va);
 }
 
+void syntax_warning(Token token, char *fmt, ...) {
+	va_list va;
+	va_start(va, fmt);
+	syntax_warning_va(token, fmt, va);
+	va_end(va);
+}
+
 
 void compiler_error(char *fmt, ...) {
 	va_list va;
@@ -834,13 +858,11 @@ Token tokenizer_get_token(Tokenizer *t) {
 			token.kind = Token_Period; // Default
 			if (t->curr_rune == '.') { // Could be an ellipsis
 				advance_to_next_rune(t);
-				if (t->curr_rune == '<') {
-					advance_to_next_rune(t);
-					token.kind = Token_HalfOpenRange;
-				} else if (t->curr_rune == '.') {
-					advance_to_next_rune(t);
-					token.kind = Token_Ellipsis;
-				}
+				token.kind = Token_Ellipsis;
+				// if (t->curr_rune == '<') {
+					// advance_to_next_rune(t);
+					// token.kind = Token_HalfOpenRange;
+				// }
 			}
 			break;