Improve package strings

1 files changed, 67 insertions, 79 deletions

diff --git a/core/sync/atomic.odin b/core/sync/atomic.odin
index 4ea715bb4..9b2a0b3d1 100644
--- a/core/sync/atomic.odin
+++ b/core/sync/atomic.odin
@@ -11,92 +11,86 @@ Ordering :: enum {
 }
 
 strongest_failure_ordering :: inline proc "contextless" (order: Ordering) -> Ordering {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return Relaxed;
-	case Release:                 return Relaxed;
-	case Acquire:                 return Acquire;
-	case Acquire_Release:         return Acquire;
-	case Sequentially_Consistent: return Sequentially_Consistent;
+	case .Relaxed:                 return .Relaxed;
+	case .Release:                 return .Relaxed;
+	case .Acquire:                 return .Acquire;
+	case .Acquire_Release:         return .Acquire;
+	case .Sequentially_Consistent: return .Sequentially_Consistent;
 	}
-	return Relaxed;
+	return .Relaxed;
 }
 
 fence :: inline proc "contextless" (order: Ordering) {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 panic("there is no such thing as a relaxed fence");
-	case Release:                 intrinsics.atomic_fence_rel();
-	case Acquire:                 intrinsics.atomic_fence_acq();
-	case Acquire_Release:         intrinsics.atomic_fence_acqrel();
-	case Sequentially_Consistent: intrinsics.atomic_fence();
+	case .Relaxed:                 panic("there is no such thing as a relaxed fence");
+	case .Release:                 intrinsics.atomic_fence_rel();
+	case .Acquire:                 intrinsics.atomic_fence_acq();
+	case .Acquire_Release:         intrinsics.atomic_fence_acqrel();
+	case .Sequentially_Consistent: intrinsics.atomic_fence();
 	case: panic("unknown order");
 	}
 }
 
 
 atomic_store :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 intrinsics.atomic_store_relaxed(dst, val);
-	case Release:                 intrinsics.atomic_store_rel(dst, val);
-	case Sequentially_Consistent: intrinsics.atomic_store(dst, val);
-	case Acquire:         panic("there is not such thing as an acquire store");
-	case Acquire_Release: panic("there is not such thing as an acquire/release store");
+	case .Relaxed:                 intrinsics.atomic_store_relaxed(dst, val);
+	case .Release:                 intrinsics.atomic_store_rel(dst, val);
+	case .Sequentially_Consistent: intrinsics.atomic_store(dst, val);
+	case .Acquire:         panic("there is not such thing as an acquire store");
+	case .Acquire_Release: panic("there is not such thing as an acquire/release store");
 	case: panic("unknown order");
 	}
 }
 
 atomic_load :: inline proc "contextless" (dst: ^$T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_load_relaxed(dst);
-	case Acquire:                 return intrinsics.atomic_load_acq(dst);
-	case Sequentially_Consistent: return intrinsics.atomic_load(dst);
-	case Release:         panic("there is no such thing as a release load");
-	case Acquire_Release: panic("there is no such thing as an acquire/release load");
+	case .Relaxed:                 return intrinsics.atomic_load_relaxed(dst);
+	case .Acquire:                 return intrinsics.atomic_load_acq(dst);
+	case .Sequentially_Consistent: return intrinsics.atomic_load(dst);
+	case .Release:         panic("there is no such thing as a release load");
+	case .Acquire_Release: panic("there is no such thing as an acquire/release load");
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_swap :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_xchg_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_xchg_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_xchg_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_xchg_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_xchg(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_xchg_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_xchg_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_xchg_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_xchg_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_xchg(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_compare_exchange :: inline proc "contextless" (dst: ^$T, old, new: T, success, failure: Ordering) -> (val: T, ok: bool) {
-	using Ordering;
 	switch failure {
-	case Relaxed:
+	case .Relaxed:
 		switch success {
-		case Relaxed:                 return intrinsics.atomic_cxchg_relaxed(dst, old, new);
-		case Acquire:                 return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new);
-		case Acquire_Release:         return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new);
-		case Sequentially_Consistent: return intrinsics.atomic_cxchg_failrelaxed(dst, old, new);
+		case .Relaxed:                 return intrinsics.atomic_cxchg_relaxed(dst, old, new);
+		case .Acquire:                 return intrinsics.atomic_cxchg_acq_failrelaxed(dst, old, new);
+		case .Acquire_Release:         return intrinsics.atomic_cxchg_acqrel_failrelaxed(dst, old, new);
+		case .Sequentially_Consistent: return intrinsics.atomic_cxchg_failrelaxed(dst, old, new);
 		case: panic("an unknown ordering combination");
 		}
-	case Acquire:
+	case .Acquire:
 		switch success {
-		case Acquire:                 return intrinsics.atomic_cxchg_acq(dst, old, new);
+		case .Acquire:                 return intrinsics.atomic_cxchg_acq(dst, old, new);
 		case: panic("an unknown ordering combination");
 		}
-	case Sequentially_Consistent:
+	case .Sequentially_Consistent:
 		switch success {
-		case Sequentially_Consistent: return intrinsics.atomic_cxchg(dst, old, new);
+		case .Sequentially_Consistent: return intrinsics.atomic_cxchg(dst, old, new);
 		case: panic("an unknown ordering combination");
 		}
-	case Acquire_Release:
+	case .Acquire_Release:
 		panic("there is not such thing as an acquire/release failure ordering");
-	case Release:
+	case .Release:
 		panic("there is not such thing as an release failure ordering");
 	}
 	return T{}, false;
@@ -105,78 +99,72 @@ atomic_compare_exchange :: inline proc "contextless" (dst: ^$T, old, new: T, suc
 
 
 atomic_add :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_add_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_add_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_add_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_add_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_add(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_add_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_add_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_add_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_add_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_add(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_sub :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_sub_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_sub_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_sub_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_sub_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_sub(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_sub_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_sub_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_sub_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_sub_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_sub(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_and :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_and_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_and_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_and_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_and_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_and(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_and_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_and_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_and_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_and_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_and(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_nand :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_nand_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_nand_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_nand_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_nand_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_nand(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_nand_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_nand_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_nand_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_nand_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_nand(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_or :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_or_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_or_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_or_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_or_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_or(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_or_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_or_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_or_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_or_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_or(dst, val);
 	}
 	panic("unknown order");
 	return T{};
 }
 
 atomic_xor :: inline proc "contextless" (dst: ^$T, val: T, order: Ordering) -> T {
-	using Ordering;
 	#complete switch order {
-	case Relaxed:                 return intrinsics.atomic_xor_relaxed(dst, val);
-	case Release:                 return intrinsics.atomic_xor_rel(dst, val);
-	case Acquire:                 return intrinsics.atomic_xor_acq(dst, val);
-	case Acquire_Release:         return intrinsics.atomic_xor_acqrel(dst, val);
-	case Sequentially_Consistent: return intrinsics.atomic_xor(dst, val);
+	case .Relaxed:                 return intrinsics.atomic_xor_relaxed(dst, val);
+	case .Release:                 return intrinsics.atomic_xor_rel(dst, val);
+	case .Acquire:                 return intrinsics.atomic_xor_acq(dst, val);
+	case .Acquire_Release:         return intrinsics.atomic_xor_acqrel(dst, val);
+	case .Sequentially_Consistent: return intrinsics.atomic_xor(dst, val);
 	}
 	panic("unknown order");
 	return T{};