Serialize errors to make them sortable, deterministic, and generally more control

src/array.cpp

@@ -51,6 +51,13 @@ template <typename T> gb_internal void array_copy(Array<T> *array, Array<T> cons
 template <typename T> gb_internal T *array_end_ptr(Array<T> *array);
 
 
+template <typename T>
+gb_internal void array_sort(Array<T> &array, gbCompareProc compare_proc) {
+	gb_sort_array(array.data, array.count, compare_proc);
+}
+
+
+
 template <typename T>
 struct Slice {
 	T *data;

src/build_settings.cpp

@@ -1272,6 +1272,10 @@ gb_internal String get_fullpath_core_collection(gbAllocator a, String path, bool
 gb_internal bool show_error_line(void) {
 	return !build_context.hide_error_line;
 }
+
+gb_internal bool terse_errors(void) {
+	return build_context.terse_errors;
+}
 gb_internal bool has_ansi_terminal_colours(void) {
 	return build_context.has_ansi_terminal_colours;
 }

src/check_builtin.cpp

@@ -1389,7 +1389,7 @@ gb_internal LoadDirectiveResult check_load_directory_directive(CheckerContext *c
 			}
 		}
 
-		gb_sort_array(file_caches.data, file_caches.count, file_cache_sort_cmp);
+		array_sort(file_caches, file_cache_sort_cmp);
 
 	}
 

src/check_expr.cpp

@@ -6485,7 +6485,7 @@ gb_internal CallArgumentData check_call_arguments_proc_group(CheckerContext *c,
 	}
 
 	if (valids.count > 1) {
-		gb_sort_array(valids.data, valids.count, valid_index_and_score_cmp);
+		array_sort(valids, valid_index_and_score_cmp);
 		i64 best_score = valids[0].score;
 		Entity *best_entity = proc_entities[valids[0].index];
 		GB_ASSERT(best_entity != nullptr);

src/checker.cpp

@@ -5044,7 +5044,7 @@ gb_internal void check_create_file_scopes(Checker *c) {
 	for_array(i, c->parser->packages) {
 		AstPackage *pkg = c->parser->packages[i];
 
-		gb_sort_array(pkg->files.data, pkg->files.count, sort_file_by_name);
+		array_sort(pkg->files, sort_file_by_name);
 
 		isize total_pkg_decl_count = 0;
 		for_array(j, pkg->files) {
@@ -5673,7 +5673,7 @@ gb_internal void remove_neighbouring_duplicate_entires_from_sorted_array(Array<E
 
 
 gb_internal void check_test_procedures(Checker *c) {
-	gb_sort_array(c->info.testing_procedures.data, c->info.testing_procedures.count, init_procedures_cmp);
+	array_sort(c->info.testing_procedures, init_procedures_cmp);
 	remove_neighbouring_duplicate_entires_from_sorted_array(&c->info.testing_procedures);
 
 	if (build_context.test_names.entries.count == 0) {
@@ -6122,8 +6122,8 @@ gb_internal GB_COMPARE_PROC(fini_procedures_cmp) {
 }
 
 gb_internal void check_sort_init_and_fini_procedures(Checker *c) {
-	gb_sort_array(c->info.init_procedures.data, c->info.init_procedures.count, init_procedures_cmp);
-	gb_sort_array(c->info.fini_procedures.data, c->info.fini_procedures.count, fini_procedures_cmp);
+	array_sort(c->info.init_procedures, init_procedures_cmp);
+	array_sort(c->info.fini_procedures, fini_procedures_cmp);
 
 	// NOTE(bill): remove possible duplicates from the init/fini lists
 	// NOTE(bill): because the arrays are sorted, you only need to check the previous element

src/common.cpp

@@ -913,7 +913,7 @@ gb_internal void did_you_mean_append(DidYouMeanAnswers *d, String const &target)
 	array_add(&d->distances, dat);
 }
 gb_internal Slice<DistanceAndTarget> did_you_mean_results(DidYouMeanAnswers *d) {
-	gb_sort_array(d->distances.data, d->distances.count, gb_isize_cmp(gb_offset_of(DistanceAndTarget, distance)));
+	array_sort(d->distances, gb_isize_cmp(gb_offset_of(DistanceAndTarget, distance)));
 	isize count = 0;
 	for (isize i = 0; i < d->distances.count; i++) {
 		isize distance = d->distances[i].distance;

src/docs.cpp

@@ -237,7 +237,7 @@ gb_internal void print_doc_package(CheckerInfo *info, AstPackage *pkg) {
 			}
 			array_add(&entities, e);
 		}
-		gb_sort_array(entities.data, entities.count, cmp_entities_for_printing);
+		array_sort(entities, cmp_entities_for_printing);
 
 		bool show_docs = (build_context.cmd_doc_flags & CmdDocFlag_Short) == 0;
 
@@ -358,7 +358,7 @@ gb_internal void generate_documentation(Checker *c) {
 			}
 		}
 
-		gb_sort_array(pkgs.data, pkgs.count, cmp_ast_package_by_name);
+		array_sort(pkgs, cmp_ast_package_by_name);
 
 		for_array(i, pkgs) {
 			print_doc_package(info, pkgs[i]);

src/docs_writer.cpp

@@ -1107,7 +1107,7 @@ gb_internal void odin_doc_write_docs(OdinDocWriter *w) {
 	}
 
 	debugf("odin_doc_update_entities sort pkgs %s\n", w->state ? "preparing" : "writing");
-	gb_sort_array(pkgs.data, pkgs.count, cmp_ast_package_by_name);
+	array_sort(pkgs, cmp_ast_package_by_name);
 
 	for_array(i, pkgs) {
 		gbAllocator allocator = heap_allocator();

src/error.cpp

@@ -1,3 +1,14 @@
+enum ErrorValueKind : u32 {
+	ErrorValue_Error,
+	ErrorValue_Warning,
+};
+
+struct ErrorValue {
+	ErrorValueKind kind;
+	TokenPos       pos;
+	Array<String>  msgs;
+};
+
 struct ErrorCollector {
 	TokenPos prev;
 	std::atomic<i64>  count;
@@ -8,21 +19,54 @@ struct ErrorCollector {
 	BlockingMutex     string_mutex;
 	RecursiveMutex    block_mutex;
 
-	RecursiveMutex error_buffer_mutex;
-	Array<u8>      error_buffer;
-	Array<String>  errors;
+	Array<ErrorValue> error_values;
+	ErrorValue        curr_error_value;
+	std::atomic<bool> curr_error_value_set;
 };
 
 gb_global ErrorCollector global_error_collector;
 
 
+gb_internal void push_error_value(TokenPos const &pos, ErrorValueKind kind = ErrorValue_Error) {
+	GB_ASSERT(global_error_collector.curr_error_value_set.load() == false);
+	ErrorValue ev = {kind, pos};
+	ev.msgs.allocator = heap_allocator();
+
+	global_error_collector.curr_error_value = ev;
+	global_error_collector.curr_error_value_set.store(true);
+}
+
+gb_internal void pop_error_value(void) {
+	if (global_error_collector.curr_error_value_set.load()) {
+		array_add(&global_error_collector.error_values, global_error_collector.curr_error_value);
+
+		global_error_collector.curr_error_value = {};
+		global_error_collector.curr_error_value_set.store(false);
+	}
+}
+
+
+gb_internal void try_pop_error_value(void) {
+	if (!global_error_collector.in_block.load()) {
+		pop_error_value();
+	}
+}
+
+gb_internal ErrorValue *get_error_value(void) {
+	GB_ASSERT(global_error_collector.curr_error_value_set.load() == true);
+	return &global_error_collector.curr_error_value;
+}
+
+
+
 gb_internal bool any_errors(void) {
 	return global_error_collector.count.load() != 0;
 }
 
+
+
 gb_internal void init_global_error_collector(void) {
-	array_init(&global_error_collector.errors, heap_allocator());
-	array_init(&global_error_collector.error_buffer, heap_allocator());
+	array_init(&global_error_collector.error_values, heap_allocator());
 	array_init(&global_file_path_strings, heap_allocator(), 1, 4096);
 	array_init(&global_files,             heap_allocator(), 1, 4096);
 }
@@ -102,6 +146,7 @@ gb_internal AstFile *thread_safe_get_ast_file_from_id(i32 index) {
 gb_internal bool global_warnings_as_errors(void);
 gb_internal bool global_ignore_warnings(void);
 gb_internal bool show_error_line(void);
+gb_internal bool terse_errors(void);
 gb_internal bool has_ansi_terminal_colours(void);
 gb_internal gbString get_file_line_as_string(TokenPos const &pos, i32 *offset);
 
@@ -113,6 +158,24 @@ gb_internal void syntax_error(Token const &token, char const *fmt, ...);
 gb_internal void syntax_error(TokenPos pos, char const *fmt, ...);
 gb_internal void syntax_warning(Token const &token, char const *fmt, ...);
 gb_internal void compiler_error(char const *fmt, ...);
+gb_internal void print_all_errors(void);
+
+
+#define ERROR_OUT_PROC(name) void name(char const *fmt, va_list va)
+typedef ERROR_OUT_PROC(ErrorOutProc);
+
+gb_internal ERROR_OUT_PROC(default_error_out_va) {
+	char buf[4096] = {};
+	isize len = gb_snprintf_va(buf, gb_size_of(buf), fmt, va);
+	isize n = len-1;
+
+	String msg = {(u8 *)buf, n};
+
+	ErrorValue *ev = get_error_value();
+	array_add(&ev->msgs, copy_string(permanent_allocator(), msg));
+}
+
+gb_global ErrorOutProc *error_out_va = default_error_out_va;
 
 gb_internal void begin_error_block(void) {
 	mutex_lock(&global_error_collector.block_mutex);
@@ -120,48 +183,7 @@ gb_internal void begin_error_block(void) {
 }
 
 gb_internal void end_error_block(void) {
-	mutex_lock(&global_error_collector.error_buffer_mutex);
-	isize n = global_error_collector.error_buffer.count;
-	if (n > 0) {
-		u8 *text = global_error_collector.error_buffer.data;
-
-		bool add_extra_newline = false;
-
-		if (show_error_line()) {
-			if (n >= 2 && !(text[n-2] == '\n' && text[n-1] == '\n')) {
-				add_extra_newline = true;
-			}
-		} else {
-			isize newline_count = 0;
-			for (isize i = 0; i < n; i++) {
-				if (text[i] == '\n') {
-					newline_count += 1;
-				}
-			}
-			if (newline_count > 1) {
-				add_extra_newline = true;
-			}
-		}
-
-		if (add_extra_newline) {
-			// add an extra new line as padding when the error line is being shown
-			error_line("\n");
-		}
-
-		n = global_error_collector.error_buffer.count;
-		text = gb_alloc_array(permanent_allocator(), u8, n+1);
-		gb_memmove(text, global_error_collector.error_buffer.data, n);
-		text[n] = 0;
-
-
-		mutex_lock(&global_error_collector.error_out_mutex);
-		String s = {text, n};
-		array_add(&global_error_collector.errors, s);
-		mutex_unlock(&global_error_collector.error_out_mutex);
-
-		global_error_collector.error_buffer.count = 0;
-	}
-	mutex_unlock(&global_error_collector.error_buffer_mutex);
+	pop_error_value();
 	global_error_collector.in_block.store(false);
 	mutex_unlock(&global_error_collector.block_mutex);
 }
@@ -169,40 +191,6 @@ gb_internal void end_error_block(void) {
 #define ERROR_BLOCK() begin_error_block(); defer (end_error_block())
 
 
-#define ERROR_OUT_PROC(name) void name(char const *fmt, va_list va)
-typedef ERROR_OUT_PROC(ErrorOutProc);
-
-gb_internal ERROR_OUT_PROC(default_error_out_va) {
-	gbFile *f = gb_file_get_standard(gbFileStandard_Error);
-
-	char buf[4096] = {};
-	isize len = gb_snprintf_va(buf, gb_size_of(buf), fmt, va);
-	isize n = len-1;
-	if (global_error_collector.in_block) {
-		mutex_lock(&global_error_collector.error_buffer_mutex);
-
-		isize cap = global_error_collector.error_buffer.count + n;
-		array_reserve(&global_error_collector.error_buffer, cap);
-		u8 *data = global_error_collector.error_buffer.data + global_error_collector.error_buffer.count;
-		gb_memmove(data, buf, n);
-		global_error_collector.error_buffer.count += n;
-
-		mutex_unlock(&global_error_collector.error_buffer_mutex);
-	} else {
-		mutex_lock(&global_error_collector.error_out_mutex);
-		{
-			u8 *text = gb_alloc_array(permanent_allocator(), u8, n+1);
-			gb_memmove(text, buf, n);
-			text[n] = 0;
-			array_add(&global_error_collector.errors, make_string(text, n));
-		}
-		mutex_unlock(&global_error_collector.error_out_mutex);
-
-	}
-	gb_file_write(f, buf, n);
-}
-
-gb_global ErrorOutProc *error_out_va = default_error_out_va;
 
 gb_internal void error_out(char const *fmt, ...) {
 	va_list va;
@@ -357,9 +345,12 @@ gb_internal void error_out_coloured(char const *str, TerminalStyle style, Termin
 gb_internal void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
 	global_error_collector.count.fetch_add(1);
 	if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
+		print_all_errors();
 		gb_exit(1);
 	}
 	mutex_lock(&global_error_collector.mutex);
+
+	push_error_value(pos, ErrorValue_Error);
 	// NOTE(bill): Duplicate error, skip it
 	if (pos.line == 0) {
 		error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -377,6 +368,7 @@ gb_internal void error_va(TokenPos const &pos, TokenPos end, char const *fmt, va
 	} else {
 		global_error_collector.count.fetch_sub(1);
 	}
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
@@ -387,6 +379,9 @@ gb_internal void warning_va(TokenPos const &pos, TokenPos end, char const *fmt,
 	}
 	global_error_collector.warning_count.fetch_add(1);
 	mutex_lock(&global_error_collector.mutex);
+
+	push_error_value(pos, ErrorValue_Warning);
+
 	if (!global_ignore_warnings()) {
 		// NOTE(bill): Duplicate error, skip it
 		if (pos.line == 0) {
@@ -402,6 +397,7 @@ gb_internal void warning_va(TokenPos const &pos, TokenPos end, char const *fmt,
 			show_error_on_line(pos, end);
 		}
 	}
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
@@ -413,9 +409,13 @@ gb_internal void error_line_va(char const *fmt, va_list va) {
 gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_list va) {
 	global_error_collector.count.fetch_add(1);
 	if (global_error_collector.count.load() > MAX_ERROR_COLLECTOR_COUNT()) {
+		print_all_errors();
 		gb_exit(1);
 	}
 	mutex_lock(&global_error_collector.mutex);
+
+	push_error_value(pos, ErrorValue_Error);
+
 	// NOTE(bill): Duplicate error, skip it
 	if (pos.line == 0) {
 		error_out_coloured("Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -428,6 +428,8 @@ gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_li
 		}
 		error_out_va(fmt, va);
 	}
+
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
@@ -435,9 +437,13 @@ gb_internal void error_no_newline_va(TokenPos const &pos, char const *fmt, va_li
 gb_internal void syntax_error_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
 	global_error_collector.count.fetch_add(1);
 	if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
+		print_all_errors();
 		gb_exit(1);
 	}
 	mutex_lock(&global_error_collector.mutex);
+
+	push_error_value(pos, ErrorValue_Warning);
+
 	// NOTE(bill): Duplicate error, skip it
 	if (global_error_collector.prev != pos) {
 		global_error_collector.prev = pos;
@@ -451,15 +457,21 @@ gb_internal void syntax_error_va(TokenPos const &pos, TokenPos end, char const *
 		error_out_va(fmt, va);
 		error_out("\n");
 	}
+
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
 gb_internal void syntax_error_with_verbose_va(TokenPos const &pos, TokenPos end, char const *fmt, va_list va) {
 	global_error_collector.count.fetch_add(1);
 	if (global_error_collector.count > MAX_ERROR_COLLECTOR_COUNT()) {
+		print_all_errors();
 		gb_exit(1);
 	}
 	mutex_lock(&global_error_collector.mutex);
+
+	push_error_value(pos, ErrorValue_Warning);
+
 	// NOTE(bill): Duplicate error, skip it
 	if (pos.line == 0) {
 		error_out_coloured("Syntax_Error: ", TerminalStyle_Normal, TerminalColour_Red);
@@ -475,6 +487,8 @@ gb_internal void syntax_error_with_verbose_va(TokenPos const &pos, TokenPos end,
 		error_out("\n");
 		show_error_on_line(pos, end);
 	}
+
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
@@ -486,6 +500,10 @@ gb_internal void syntax_warning_va(TokenPos const &pos, TokenPos end, char const
 	}
 	mutex_lock(&global_error_collector.mutex);
 	global_error_collector.warning_count++;
+
+
+	push_error_value(pos, ErrorValue_Warning);
+
 	if (!global_ignore_warnings()) {
 		// NOTE(bill): Duplicate error, skip it
 		if (global_error_collector.prev != pos) {
@@ -501,6 +519,8 @@ gb_internal void syntax_warning_va(TokenPos const &pos, TokenPos end, char const
 			error_out("\n");
 		}
 	}
+
+	try_pop_error_value();
 	mutex_unlock(&global_error_collector.mutex);
 }
 
@@ -568,6 +588,8 @@ gb_internal void syntax_error_with_verbose(TokenPos pos, TokenPos end, char cons
 
 
 gb_internal void compiler_error(char const *fmt, ...) {
+	print_all_errors();
+
 	va_list va;
 
 	va_start(va, fmt);
@@ -577,3 +599,34 @@ gb_internal void compiler_error(char const *fmt, ...) {
 	GB_DEBUG_TRAP();
 	gb_exit(1);
 }
+
+
+
+
+
+gb_internal int error_value_cmp(void const *a, void const *b) {
+	ErrorValue *x = cast(ErrorValue *)a;
+	ErrorValue *y = cast(ErrorValue *)b;
+	return token_pos_cmp(x->pos, y->pos);
+}
+
+gb_internal void print_all_errors(void) {
+	GB_ASSERT(any_errors());
+	gbFile *f = gb_file_get_standard(gbFileStandard_Error);
+
+	array_sort(global_error_collector.error_values, error_value_cmp);
+
+	for_array(i, global_error_collector.error_values) {
+		ErrorValue ev = global_error_collector.error_values[i];
+		for_array(j, ev.msgs) {
+			String msg = ev.msgs[j];
+			gb_file_write(f, msg.text, msg.len);
+			if (terse_errors()) {
+				if (string_contains_char(msg, '\n')) {
+					break;
+				}
+			}
+		}
+	}
+
+}

src/llvm_backend.cpp

@@ -3021,7 +3021,7 @@ gb_internal bool lb_generate_code(lbGenerator *gen) {
 		}
 	}
 
-	gb_sort_array(gen->foreign_libraries.data, gen->foreign_libraries.count, foreign_library_cmp);
+	array_sort(gen->foreign_libraries, foreign_library_cmp);
 
 	return true;
 }

src/main.cpp

@@ -2095,7 +2095,7 @@ gb_internal void print_show_unused(Checker *c) {
 		array_add(&unused, e);
 	}
 
-	gb_sort_array(unused.data, unused.count, cmp_entities_for_printing);
+	array_sort(unused, cmp_entities_for_printing);
 
 	print_usage_line(0, "Unused Package Declarations");
 
@@ -2680,6 +2680,7 @@ int main(int arg_count, char const **arg_ptr) {
 	}
 
 	if (any_errors()) {
+		print_all_errors();
 		return 1;
 	}
 
@@ -2691,6 +2692,7 @@ int main(int arg_count, char const **arg_ptr) {
 
 	check_parsed_files(checker);
 	if (any_errors()) {
+		print_all_errors();
 		return 1;
 	}
 

src/string.cpp

@@ -89,7 +89,6 @@ gb_internal char *alloc_cstring(gbAllocator a, String s) {
 }
 
 
-
 gb_internal gb_inline bool str_eq_ignore_case(String const &a, String const &b) {
 	if (a.len == b.len) {
 		for (isize i = 0; i < a.len; i++) {