Improve parsing for `or_return`; allow `#force_inline foo() or_return;`

5 files changed, 38 insertions, 38 deletions

diff --git a/core/math/big/helpers.odin b/core/math/big/helpers.odin
index 92fce3c52..ab686b914 100644
--- a/core/math/big/helpers.odin
+++ b/core/math/big/helpers.odin
@@ -42,7 +42,7 @@ int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, allocator :
 		Check that `src` is usable and `dest` isn't immutable.
 	*/
 	assert_if_nil(dest);
-	(#force_inline internal_error_if_immutable(dest)) or_return;
+	#force_inline internal_error_if_immutable(dest) or_return;
 
 	return #force_inline internal_int_set_from_integer(dest, src, minimize);
 }
@@ -64,8 +64,8 @@ int_copy :: proc(dest, src: ^Int, minimize := false, allocator := context.alloca
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	(#force_inline internal_clear_if_uninitialized(src)) or_return;
-	(#force_inline internal_error_if_immutable(dest))    or_return;
+	#force_inline internal_clear_if_uninitialized(src) or_return;
+	#force_inline internal_error_if_immutable(dest)    or_return;
 
 	return #force_inline internal_int_copy(dest, src, minimize);
 }
@@ -92,8 +92,8 @@ int_abs :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	(#force_inline internal_clear_if_uninitialized(src)) or_return;
-	(#force_inline internal_error_if_immutable(dest))    or_return;
+	#force_inline internal_clear_if_uninitialized(src) or_return;
+	#force_inline internal_error_if_immutable(dest)    or_return;
 
 	return #force_inline internal_int_abs(dest, src);
 }
@@ -113,8 +113,8 @@ int_neg :: proc(dest, src: ^Int, allocator := context.allocator) -> (err: Error)
 	assert_if_nil(dest, src);
 	context.allocator = allocator;
 
-	(#force_inline internal_clear_if_uninitialized(src)) or_return;
-	(#force_inline internal_error_if_immutable(dest))    or_return;
+	#force_inline internal_clear_if_uninitialized(src) or_return;
+	#force_inline internal_error_if_immutable(dest)    or_return;
 
 	return #force_inline internal_int_neg(dest, src);
 }
@@ -134,7 +134,7 @@ int_bitfield_extract :: proc(a: ^Int, offset, count: int, allocator := context.a
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	(#force_inline internal_clear_if_uninitialized(a)) or_return;
+	#force_inline internal_clear_if_uninitialized(a) or_return;
 	return #force_inline internal_int_bitfield_extract(a, offset, count);
 }
 
@@ -148,7 +148,7 @@ shrink :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
 	context.allocator = allocator;
 
-	(#force_inline internal_clear_if_uninitialized(a)) or_return;
+	#force_inline internal_clear_if_uninitialized(a) or_return;
 	return #force_inline internal_shrink(a);
 }
 
@@ -305,7 +305,7 @@ int_get :: proc(a: ^Int, $T: typeid, allocator := context.allocator) -> (res: T,
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 	return #force_inline internal_int_get(a, T);
 }
 get :: proc { int_get, };
@@ -315,7 +315,7 @@ int_get_float :: proc(a: ^Int, allocator := context.allocator) -> (res: f64, err
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 	return #force_inline internal_int_get_float(a);
 }
 
@@ -327,7 +327,7 @@ count_bits :: proc(a: ^Int, allocator := context.allocator) -> (count: int, err:
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 	return #force_inline internal_count_bits(a), nil;
 }
 
@@ -340,7 +340,7 @@ int_count_lsb :: proc(a: ^Int, allocator := context.allocator) -> (count: int, e
 		Check that `a` is usable.
 	*/
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 	return #force_inline internal_int_count_lsb(a);
 }
 
@@ -398,7 +398,7 @@ clear_if_uninitialized_multi :: proc(args: ..^Int, allocator := context.allocato
 	assert_if_nil(..args);
 
 	for i in &args {
-		(#force_inline internal_clear_if_uninitialized_single(i, allocator)) or_return;
+		#force_inline internal_clear_if_uninitialized_single(i, allocator) or_return;
 	}
 	return err;
 }
@@ -425,7 +425,7 @@ int_init_multi :: proc(integers: ..^Int, allocator := context.allocator) -> (err
 
 	integers := integers;
 	for a in &integers {
-		(#force_inline internal_clear(a, true, allocator)) or_return;
+		#force_inline internal_clear(a, true, allocator) or_return;
 	}
 	return nil;
 }
@@ -440,7 +440,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
 		Check that `src` is usable and `dest` isn't immutable.
 	*/
 	assert_if_nil(dest, src);
-	(#force_inline internal_clear_if_uninitialized(src)) or_return;
+	#force_inline internal_clear_if_uninitialized(src) or_return;
 
 	digits = min(digits, len(src.digit), len(dest.digit));
 	return #force_inline internal_copy_digits(dest, src, digits);
@@ -454,7 +454,7 @@ copy_digits :: proc(dest, src: ^Int, digits: int, allocator := context.allocator
 */
 clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 
 	for a.used > 0 && a.digit[a.used - 1] == 0 {
 		a.used -= 1;
@@ -472,7 +472,7 @@ clamp :: proc(a: ^Int, allocator := context.allocator) -> (err: Error) {
 */
 int_to_bytes_size :: proc(a: ^Int, signed := false, allocator := context.allocator) -> (size_in_bytes: int, err: Error) {
 	assert_if_nil(a);
-	(#force_inline internal_clear_if_uninitialized(a, allocator)) or_return;
+	#force_inline internal_clear_if_uninitialized(a, allocator) or_return;
 
 	size_in_bits := internal_count_bits(a);
 
diff --git a/core/math/big/internal.odin b/core/math/big/internal.odin
index e23c484b2..2c988f91e 100644
--- a/core/math/big/internal.odin
+++ b/core/math/big/internal.odin
@@ -852,7 +852,7 @@ internal_div :: proc { internal_int_div, };
 	Asssumes quotient, numerator and denominator to have been initialized and not to be nil.
 */
 internal_int_mod :: proc(remainder, numerator, denominator: ^Int, allocator := context.allocator) -> (err: Error) {
-	(#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator)) or_return;
+	#force_inline internal_int_divmod(nil, remainder, numerator, denominator, allocator) or_return;
 
 	if remainder.used == 0 || denominator.sign == remainder.sign { return nil; }
 
@@ -864,7 +864,7 @@ internal_mod :: proc{ internal_int_mod, };
 	remainder = (number + addend) % modulus.
 */
 internal_int_addmod :: proc(remainder, number, addend, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	(#force_inline internal_add(remainder, number, addend, allocator)) or_return;
+	#force_inline internal_add(remainder, number, addend, allocator) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_addmod :: proc { internal_int_addmod, };
@@ -873,7 +873,7 @@ internal_addmod :: proc { internal_int_addmod, };
 	remainder = (number - decrease) % modulus.
 */
 internal_int_submod :: proc(remainder, number, decrease, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	(#force_inline internal_sub(remainder, number, decrease, allocator)) or_return;
+	#force_inline internal_sub(remainder, number, decrease, allocator) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_submod :: proc { internal_int_submod, };
@@ -882,7 +882,7 @@ internal_submod :: proc { internal_int_submod, };
 	remainder = (number * multiplicand) % modulus.
 */
 internal_int_mulmod :: proc(remainder, number, multiplicand, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	(#force_inline internal_mul(remainder, number, multiplicand, allocator)) or_return;
+	#force_inline internal_mul(remainder, number, multiplicand, allocator) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_mulmod :: proc { internal_int_mulmod, };
@@ -891,7 +891,7 @@ internal_mulmod :: proc { internal_int_mulmod, };
 	remainder = (number * number) % modulus.
 */
 internal_int_sqrmod :: proc(remainder, number, modulus: ^Int, allocator := context.allocator) -> (err: Error) {
-	(#force_inline internal_sqr(remainder, number, allocator)) or_return;
+	#force_inline internal_sqr(remainder, number, allocator) or_return;
 	return #force_inline internal_mod(remainder, remainder, modulus, allocator);
 }
 internal_sqrmod :: proc { internal_int_sqrmod, };
@@ -914,7 +914,7 @@ internal_int_factorial :: proc(res: ^Int, n: int, allocator := context.allocator
 		return #force_inline internal_set(res, _factorial_table[n]);
 	}
 
-	(#force_inline internal_set(res, _factorial_table[i - 1])) or_return;
+	#force_inline internal_set(res, _factorial_table[i - 1]) or_return;
 	for {
 		if err = #force_inline internal_mul(res, res, DIGIT(i)); err != nil || i == n {
 			return err;
@@ -1629,7 +1629,7 @@ internal_int_set_from_integer :: proc(dest: ^Int, src: $T, minimize := false, al
 internal_set :: proc { internal_int_set_from_integer, internal_int_copy };
 
 internal_copy_digits :: #force_inline proc(dest, src: ^Int, digits: int) -> (err: Error) {
-	(#force_inline internal_error_if_immutable(dest)) or_return;
+	#force_inline internal_error_if_immutable(dest) or_return;
 
 	/*
 		If dest == src, do nothing
@@ -2436,7 +2436,7 @@ internal_int_shl_digit :: proc(quotient: ^Int, digits: int, allocator := context
 	/*
 		Resize `quotient` to accomodate extra digits.
 	*/
-	(#force_inline internal_grow(quotient, quotient.used + digits)) or_return;
+	#force_inline internal_grow(quotient, quotient.used + digits) or_return;
 
 	/*
 		Increment the used by the shift amount then copy upwards.
@@ -2534,7 +2534,7 @@ internal_int_rand :: proc(dest: ^Int, bits: int, r: ^rnd.Rand = nil, allocator :
 		digits += 1;
 	}
 
-	(#force_inline internal_grow(dest, digits)) or_return;
+	#force_inline internal_grow(dest, digits) or_return;
 
 	for i := 0; i < digits; i += 1 {
 		dest.digit[i] = int_random_digit(r) & _MASK;
diff --git a/core/math/big/prime.odin b/core/math/big/prime.odin
index 90eb2e4f7..b022870a6 100644
--- a/core/math/big/prime.odin
+++ b/core/math/big/prime.odin
@@ -22,7 +22,7 @@ int_prime_is_divisible :: proc(a: ^Int, allocator := context.allocator) -> (res:
 	internal_clear_if_uninitialized(a) or_return;
 
 	for prime in _private_prime_table {
-		rem := (#force_inline int_mod_digit(a, prime)) or_return;
+		rem := #force_inline int_mod_digit(a, prime) or_return;
 		if rem == 0 {
 			return true, nil;
 		}
diff --git a/core/math/big/private.odin b/core/math/big/private.odin
index 14c2464d0..a99d6119f 100644
--- a/core/math/big/private.odin
+++ b/core/math/big/private.odin
@@ -1268,17 +1268,17 @@ _private_int_log :: proc(a: ^Int, base: DIGIT, allocator := context.allocator) -
 		}

 

 		low = high;

-		(#force_inline internal_copy(bracket_low, bracket_high)) or_return;

+		#force_inline internal_copy(bracket_low, bracket_high) or_return;

 		high <<= 1;

-		(#force_inline internal_sqr(bracket_high, bracket_high)) or_return;

+		#force_inline internal_sqr(bracket_high, bracket_high) or_return;

 	}

 

 	for (high - low) > 1 {

 		mid := (high + low) >> 1;

 

-		(#force_inline internal_pow(t, bi_base, mid - low)) or_return;

+		#force_inline internal_pow(t, bi_base, mid - low) or_return;

 

-		(#force_inline internal_mul(bracket_mid, bracket_low, t)) or_return;

+		#force_inline internal_mul(bracket_mid, bracket_low, t) or_return;

 

 		mc := #force_inline internal_cmp(a, bracket_mid);

 		switch mc {

diff --git a/core/math/big/public.odin b/core/math/big/public.odin
index edcee106d..7804978a5 100644
--- a/core/math/big/public.odin
+++ b/core/math/big/public.odin
@@ -196,7 +196,7 @@ int_div_digit :: proc(quotient, numerator: ^Int, denominator: DIGIT, allocator :
 

 	internal_clear_if_uninitialized(numerator) or_return;

 

-	_ = (#force_inline internal_divmod(quotient, numerator, denominator)) or_return;

+	_ = #force_inline internal_divmod(quotient, numerator, denominator) or_return;

 	return;

 }

 div :: proc { int_div, int_div_digit, };

@@ -311,12 +311,12 @@ int_choose_digit :: proc(res: ^Int, n, k: int, allocator := context.allocator) -
 	n_fac, k_fac, n_minus_k_fac := &Int{}, &Int{}, &Int{};

 	defer internal_destroy(n_fac, k_fac, n_minus_k_fac);

 

-	(#force_inline internal_int_factorial(n_minus_k_fac, n - k)) or_return;

-	(#force_inline internal_int_factorial(k_fac, k))             or_return;

-	(#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac))    or_return;

+	#force_inline internal_int_factorial(n_minus_k_fac, n - k) or_return;

+	#force_inline internal_int_factorial(k_fac, k)             or_return;

+	#force_inline internal_mul(k_fac, k_fac, n_minus_k_fac)    or_return;

 

-	(#force_inline internal_int_factorial(n_fac, n))             or_return;

-	(#force_inline internal_div(res, n_fac, k_fac))              or_return;

+	#force_inline internal_int_factorial(n_fac, n)             or_return;

+	#force_inline internal_div(res, n_fac, k_fac)              or_return;

 

 	return;

 }