New faults and syntax (#2034)

- Remove `[?]` syntax.
- Change `int!` to `int?` syntax.
- New `fault` declarations.
- Enum associated values can reference the calling enum.

lib/std/core/allocators/arena_allocator.c3

@@ -28,7 +28,7 @@ fn void ArenaAllocator.clear(&self)
 struct ArenaAllocatorHeader @local
 {
 	usz size;
-	char[?] data;
+	char[*] data;
 }
 
 macro ArenaAllocator* wrap(char[] bytes)
@@ -57,17 +57,18 @@ fn void ArenaAllocator.reset(&self, usz mark) @dynamic => self.used = mark;
  @require !alignment || math::is_power_of_2(alignment)
  @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require size > 0
+ @return! mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE?;
 	void* start_mem = self.data.ptr;
 	void* unaligned_pointer_to_offset = start_mem + self.used + ArenaAllocatorHeader.sizeof;
 	void* mem = mem::aligned_pointer(unaligned_pointer_to_offset, alignment);
 	usz end = (usz)(mem - self.data.ptr) + size;
-	if (end > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+	if (end > total_len) return mem::OUT_OF_MEMORY?;
 	self.used = end;
 	ArenaAllocatorHeader* header = mem - ArenaAllocatorHeader.sizeof;
 	header.size = size;
@@ -80,13 +81,14 @@ fn void*! ArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz a
  @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require old_pointer != null
  @require size > 0
+ @return! mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
+fn void*? ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	assert(old_pointer >= self.data.ptr, "Pointer originates from a different allocator.");
 	usz total_len = self.data.len;
-	if (size > total_len) return AllocationFailure.CHUNK_TOO_LARGE?;
+	if (size > total_len) return mem::INVALID_ALLOC_SIZE?;
 	ArenaAllocatorHeader* header = old_pointer - ArenaAllocatorHeader.sizeof;
 	usz old_size = header.size;
 	// Do last allocation and alignment match?
@@ -99,7 +101,7 @@ fn void*! ArenaAllocator.resize(&self, void *old_pointer, usz size, usz alignmen
 		else
 		{
 			usz new_used = self.used + size - old_size;
-			if (new_used > total_len) return AllocationFailure.OUT_OF_MEMORY?;
+			if (new_used > total_len) return mem::OUT_OF_MEMORY?;
 			self.used = new_used;
 		}
 		header.size = size;

lib/std/core/allocators/dynamic_arena.c3

@@ -78,8 +78,9 @@ fn void DynamicArenaAllocator.release(&self, void* ptr, bool) @dynamic
  @require size > 0 : `Resize doesn't support zeroing`
  @require old_pointer != null : `Resize doesn't handle null pointers`
  @require self.page != null  : `tried to realloc pointer on invalid allocator`
+ @return! mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? DynamicArenaAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	DynamicArenaPage* current_page = self.page;
 	alignment = alignment_for_allocation(alignment);
@@ -129,15 +130,16 @@ fn void DynamicArenaAllocator.reset(&self, usz mark = 0) @dynamic
 <*
  @require math::is_power_of_2(alignment)
  @require size > 0
+ @return! mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
+fn void*? DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @local
 {
 	// First, make sure that we can align it, extending the page size if needed.
 	usz page_size = max(self.page_size, mem::aligned_offset(size + DynamicArenaChunk.sizeof + alignment, alignment));
 	assert(page_size > size + DynamicArenaChunk.sizeof);
 	// Grab the page without alignment (we do it ourselves)
 	void* mem = allocator::malloc_try(self.backing_allocator, page_size)!;
-	DynamicArenaPage*! page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
+	DynamicArenaPage*? page = allocator::new_try(self.backing_allocator, DynamicArenaPage);
 	if (catch err = page)
 	{
 		allocator::free(self.backing_allocator, mem);
@@ -159,8 +161,9 @@ fn void*! DynamicArenaAllocator._alloc_new(&self, usz size, usz alignment) @loca
 <*
  @require size > 0 : `acquire expects size > 0`
  @require !alignment || math::is_power_of_2(alignment)
+ @return! mem::INVALID_ALLOC_SIZE, mem::OUT_OF_MEMORY
 *>
-fn void*! DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? DynamicArenaAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	DynamicArenaPage* page = self.page;

lib/std/core/allocators/heap_allocator.c3

@@ -21,7 +21,7 @@ fn void SimpleHeapAllocator.init(&self, MemoryAllocFn allocator)
 	self.free_list = null;
 }
 
-fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
@@ -30,7 +30,7 @@ fn void*! SimpleHeapAllocator.acquire(&self, usz size, AllocInitType init_type,
 	return alignment > 0 ? @aligned_alloc(self._alloc, size, alignment) : self._alloc(size);
 }
 
-fn void*! SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? SimpleHeapAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	return alignment > 0
 		? @aligned_realloc(self._calloc, self._free, old_pointer, size, alignment)
@@ -52,7 +52,7 @@ fn void SimpleHeapAllocator.release(&self, void* old_pointer, bool aligned) @dyn
 <*
  @require old_pointer && bytes > 0
 *>
-fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
+fn void*? SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @local
 {
 	// Find the block header.
 	Header* block = (Header*)old_pointer - 1;
@@ -64,14 +64,14 @@ fn void*! SimpleHeapAllocator._realloc(&self, void* old_pointer, usz bytes) @loc
 	return new;
 }
 
-fn void*! SimpleHeapAllocator._calloc(&self, usz bytes) @local
+fn void*? SimpleHeapAllocator._calloc(&self, usz bytes) @local
 {
 	void* data = self._alloc(bytes)!;
 	mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	return data;
 }
 
-fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
+fn void*? SimpleHeapAllocator._alloc(&self, usz bytes) @local
 {
 	usz aligned_bytes = mem::aligned_offset(bytes, mem::DEFAULT_MEM_ALIGNMENT);
 	if (!self.free_list)
@@ -120,7 +120,7 @@ fn void*! SimpleHeapAllocator._alloc(&self, usz bytes) @local
 	return self._alloc(aligned_bytes);
 }
 
-fn void! SimpleHeapAllocator.add_block(&self, usz aligned_bytes) @local
+fn void? SimpleHeapAllocator.add_block(&self, usz aligned_bytes) @local
 {
 	assert(mem::aligned_offset(aligned_bytes, mem::DEFAULT_MEM_ALIGNMENT) == aligned_bytes);
 	char[] result = self.alloc_fn(aligned_bytes + Header.sizeof)!;

lib/std/core/allocators/libc_allocator.c3

@@ -10,36 +10,36 @@ const LibcAllocator LIBC_ALLOCATOR = {};
 distinct LibcAllocator (Allocator, Printable) = uptr;
 
 fn String LibcAllocator.to_string(&self, Allocator allocator) @dynamic => "Libc allocator".copy(allocator);
-fn usz! LibcAllocator.to_format(&self, Formatter *format) @dynamic => format.print("Libc allocator");
+fn usz? LibcAllocator.to_format(&self, Formatter *format) @dynamic => format.print("Libc allocator");
 
 module std::core::mem::allocator @if(env::POSIX);
 import std::os;
 import libc;
 
 
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		void* data @noinit;
 		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
 		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY?;
 			mem::clear(data, bytes, mem::DEFAULT_MEM_ALIGNMENT);
 			return data;
 		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY?;
 	}
 	else
 	{
 		void* data @noinit;
 		if (alignment > mem::DEFAULT_MEM_ALIGNMENT)
 		{
-			if (posix::posix_memalign(&data, alignment, bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+			if (posix::posix_memalign(&data, alignment, bytes)) return mem::OUT_OF_MEMORY?;
 		}
 		else
 		{
-			if (!(data = libc::malloc(bytes))) return AllocationFailure.OUT_OF_MEMORY?;
+			if (!(data = libc::malloc(bytes))) return mem::OUT_OF_MEMORY?;
 		}
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
@@ -48,11 +48,11 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 	}
 }
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
-	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	if (alignment <= mem::DEFAULT_MEM_ALIGNMENT) return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY?;
 	void* new_ptr;
-	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return AllocationFailure.OUT_OF_MEMORY?;
+	if (posix::posix_memalign(&new_ptr, alignment, new_bytes)) return mem::OUT_OF_MEMORY?;
 
 	$switch:
 	$case env::DARWIN:
@@ -78,31 +78,31 @@ module std::core::mem::allocator @if(env::WIN32);
 import std::os::win32;
 import libc;
 
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		if (alignment > 0)
 		{
-			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+			return win32::_aligned_recalloc(null, 1, bytes, alignment) ?: mem::OUT_OF_MEMORY?;
 		}
-		return libc::calloc(1, bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return libc::calloc(1, bytes) ?: mem::OUT_OF_MEMORY?;
 	}
 	void* data = alignment > 0 ? win32::_aligned_malloc(bytes, alignment) : libc::malloc(bytes);
-	if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+	if (!data) return mem::OUT_OF_MEMORY?;
 	$if env::TESTING:
 		for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
 	$endif
 	return data;
 }
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
 	if (alignment)
 	{
-		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: AllocationFailure.OUT_OF_MEMORY?;
+		return win32::_aligned_realloc(old_ptr, new_bytes, alignment) ?: mem::OUT_OF_MEMORY?;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY?;
 }
 
 fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
@@ -118,17 +118,17 @@ fn void LibcAllocator.release(&self, void* old_ptr, bool aligned) @dynamic
 module std::core::mem::allocator @if(!env::WIN32 && !env::POSIX && env::LIBC);
 import libc;
 
-fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
+fn void*? LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz alignment) @dynamic
 {
 	if (init_type == ZERO)
 	{
 		void* data = alignment ? @aligned_alloc(fn void*(usz bytes) => libc::calloc(bytes, 1), bytes, alignment)!! : libc::calloc(bytes, 1);
-		return data ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORYY?;
 	}
 	else
 	{
 		void* data = alignment ? @aligned_alloc(libc::malloc, bytes, alignment)!! : libc::malloc(bytes);
-		if (!data) return AllocationFailure.OUT_OF_MEMORY?;
+		if (!data) return mem::OUT_OF_MEMORY?;
 		$if env::TESTING:
 			for (usz i = 0; i < bytes; i++) ((char*)data)[i] = 0xAA;
 		$endif
@@ -137,14 +137,14 @@ fn void*! LibcAllocator.acquire(&self, usz bytes, AllocInitType init_type, usz a
 }
 
 
-fn void*! LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
+fn void*? LibcAllocator.resize(&self, void* old_ptr, usz new_bytes, usz alignment) @dynamic
 {
 	if (alignment)
 	{
 		void* data = @aligned_realloc(fn void*(usz bytes) => libc::malloc(bytes), libc::free, old_ptr, new_bytes, alignment)!!;
-		return data ?: AllocationFailure.OUT_OF_MEMORY?;
+		return data ?: mem::OUT_OF_MEMORY?;
 	}
-	return libc::realloc(old_ptr, new_bytes) ?: AllocationFailure.OUT_OF_MEMORY?;
+	return libc::realloc(old_ptr, new_bytes) ?: mem::OUT_OF_MEMORY?;
 }
 
 

lib/std/core/allocators/on_stack_allocator.c3

@@ -52,7 +52,7 @@ fn void OnStackAllocator.free(&self)
 struct OnStackAllocatorHeader
 {
 	usz size;
-	char[?] data;
+	char[*] data;
 }
 
 <*
@@ -104,7 +104,7 @@ fn OnStackAllocatorExtraChunk* on_stack_allocator_find_chunk(OnStackAllocator* a
  @require old_pointer != null
  @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	if (!allocation_in_stack_mem(self, old_pointer))
 	{
@@ -124,7 +124,7 @@ fn void*! OnStackAllocator.resize(&self, void* old_pointer, usz size, usz alignm
  @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
  @require size > 0
 *>
-fn void*! OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? OnStackAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	bool aligned = alignment > 0;
 	alignment = alignment_for_allocation(alignment);

lib/std/core/allocators/temp_allocator.c3

@@ -4,7 +4,7 @@ import std::io, std::math;
 struct TempAllocatorChunk @local
 {
 	usz size;
-	char[?] data;
+	char[*] data;
 }
 
 struct TempAllocator (Allocator)
@@ -13,7 +13,7 @@ struct TempAllocator (Allocator)
 	TempAllocatorPage* last_page;
 	usz used;
 	usz capacity;
-	char[?] data;
+	char[*] data;
 }
 
 const usz PAGE_IS_ALIGNED @private = (usz)isz.max + 1u;
@@ -26,7 +26,7 @@ struct TempAllocatorPage
 	usz mark;
 	usz size;
 	usz ident;
-	char[?] data;
+	char[*] data;
 }
 
 macro usz TempAllocatorPage.pagesize(&self) => self.size & ~PAGE_IS_ALIGNED;
@@ -35,7 +35,7 @@ macro bool TempAllocatorPage.is_aligned(&self) => self.size & PAGE_IS_ALIGNED ==
 <*
  @require size >= 16
 *>
-fn TempAllocator*! new_temp_allocator(usz size, Allocator allocator)
+fn TempAllocator*? new_temp_allocator(usz size, Allocator allocator)
 {
 	TempAllocator* temp = allocator::alloc_with_padding(allocator, TempAllocator, size)!;
 	temp.last_page = null;
@@ -90,13 +90,13 @@ fn void TempAllocator.reset(&self, usz mark) @dynamic
 	self.used = mark;
 }
 
-fn void! TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
+fn void? TempAllocator._free_page(&self, TempAllocatorPage* page) @inline @local
 {
 	void* mem = page.start;
 	return self.backing_allocator.release(mem, page.is_aligned());
 }
 
-fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
+fn void*? TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size, usz alignment) @inline @local
 {
 	// Then the actual start pointer:
 	void* real_pointer = page.start;
@@ -117,7 +117,7 @@ fn void*! TempAllocator._realloc_page(&self, TempAllocatorPage* page, usz size,
 	return data;
 }
 
-fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
+fn void*? TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @dynamic
 {
 	TempAllocatorChunk *chunk = pointer - TempAllocatorChunk.sizeof;
 	if (chunk.size == (usz)-1)
@@ -139,7 +139,7 @@ fn void*! TempAllocator.resize(&self, void* pointer, usz size, usz alignment) @d
  @require !alignment || math::is_power_of_2(alignment)
  @require alignment <= mem::MAX_MEMORY_ALIGNMENT : `alignment too big`
 *>
-fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	alignment = alignment_for_allocation(alignment);
 	void* start_mem = &self.data;
@@ -210,7 +210,7 @@ fn void*! TempAllocator.acquire(&self, usz size, AllocInitType init_type, usz al
 	return &page.data[0];
 }
 
-fn void! TempAllocator.print_pages(&self, File* f)
+fn void? TempAllocator.print_pages(&self, File* f)
 {
 	TempAllocatorPage *last_page = self.last_page;
 	if (!last_page)

lib/std/core/allocators/tracking_allocator.c3

@@ -76,7 +76,7 @@ fn Allocation[] TrackingAllocator.allocations_tlist(&self, Allocator allocator)
 *>
 fn usz TrackingAllocator.allocation_count(&self) => self.map.count;
 
-fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
+fn void*? TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, usz alignment) @dynamic
 {
 	void* data = self.inner_allocator.acquire(size, init_type, alignment)!;
 	self.allocs_total++;
@@ -87,7 +87,7 @@ fn void*! TrackingAllocator.acquire(&self, usz size, AllocInitType init_type, us
 	return data;
 }
 
-fn void*! TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
+fn void*? TrackingAllocator.resize(&self, void* old_pointer, usz size, usz alignment) @dynamic
 {
 	void* data = self.inner_allocator.resize(old_pointer, size, alignment)!;
 	self.map.remove((uptr)old_pointer);
@@ -121,7 +121,7 @@ fn bool TrackingAllocator.has_leaks(&self)
 fn void TrackingAllocator.print_report(&self) => self.fprint_report(io::stdout())!!;
 
 
-fn void! TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
+fn void? TrackingAllocator.fprint_report(&self, OutStream out) => @pool()
 {
 	usz total = 0;
 	usz entries = 0;