diff --git a/releasenotes.md b/releasenotes.md
index ab06835a6..a51605fbd 100644
--- a/releasenotes.md
+++ b/releasenotes.md
@@ -15,6 +15,7 @@
 - Improve ordering of method registration to support adding methods to generic modules with method constraints #1746
 - Support experimental `@operator(construct)` operator overload.
 - Allow using 'var' to declare lambdas in functions.
+- Add 'warnings' setting and make dead code a warning.
 
 ### Fixes
 - Fix case trying to initialize a `char[*]*` from a String.
diff --git a/src/build/build.h b/src/build/build.h
index eba59c34f..12c160967 100644
--- a/src/build/build.h
+++ b/src/build/build.h
@@ -148,6 +148,14 @@ typedef enum
 	PANIC_ON = 1,
 } PanicLevel;
 
+typedef enum
+{
+	WARNING_NOT_SET = -1,
+	WARNING_NORMAL = 0,
+	WARNING_ERROR = 1,
+	WARNING_OBNOXIOUS = 2,
+} WarningLevel;
+
 typedef enum
 {
 	SINGLE_MODULE_NOT_SET = -1,
@@ -443,6 +451,7 @@ typedef struct BuildOptions_
 	const char *vendor_download_path;
 	const char *template;
 	LinkerType linker_type;
+	WarningLevel warning_level;
 	const char *custom_linker_path;
 	uint32_t symtab_size;
 	unsigned version;
@@ -610,6 +619,7 @@ typedef struct
 	MemoryEnvironment memory_environment;
 	SizeOptimizationLevel optsize;
 	SingleModule single_module;
+	WarningLevel warning_level;
 	UseStdlib use_stdlib;
 	EmitStdlib emit_stdlib;
 	LinkLibc link_libc;
@@ -699,6 +709,7 @@ static BuildTarget default_build_target = {
 		.link_libc = LINK_LIBC_NOT_SET,
 		.emit_stdlib = EMIT_STDLIB_NOT_SET,
 		.linker_type = LINKER_TYPE_NOT_SET,
+		.warning_level = WARNING_NOT_SET,
 		.single_module = SINGLE_MODULE_NOT_SET,
 		.unroll_loops = UNROLL_LOOPS_NOT_SET,
 		.merge_functions = MERGE_FUNCTIONS_NOT_SET,
diff --git a/src/build/build_internal.h b/src/build/build_internal.h
index 5d9227a7c..fa90a6c14 100644
--- a/src/build/build_internal.h
+++ b/src/build/build_internal.h
@@ -94,6 +94,12 @@ static const char *backends[3] = {
 		[BACKEND_C] = "c",
 };
 
+static const char *warnings[3] = {
+	[WARNING_NORMAL] = "normal",
+	[WARNING_ERROR] = "error",
+	[WARNING_OBNOXIOUS] = "obnoxious",
+};
+
 static const char *backtrace_levels[2] = {
 	[SHOW_BACKTRACE_OFF] = "off",
 	[SHOW_BACKTRACE_ON] = "on",
diff --git a/src/build/build_options.c b/src/build/build_options.c
index a4060b91f..e92af2d9c 100644
--- a/src/build/build_options.c
+++ b/src/build/build_options.c
@@ -97,6 +97,7 @@ static void usage(bool full)
 	PRINTF("  --lib <name>               - Add this c3l library to the compilation.");
 	if (full)
 	{
+		PRINTF("  --warnings=<option>        - How to treat warnings: normal (default), error (treat as errors), obnoxious (more errors)");
 		PRINTF("  --stdlib <dir>             - Use this directory as the C3 standard library path.");
 		PRINTF("  --no-entry                 - Do not generate (or require) a main function.");
 		PRINTF("  --path <dir>               - Use this as the base directory for the current command.");
@@ -621,6 +622,11 @@ static void parse_option(BuildOptions *options)
 			}
 			break;
 		case '-':
+			if ((argopt = match_argopt("warnings")))
+			{
+				options->warning_level = (WarningLevel)parse_multi_option(argopt, 3, warnings);
+				return;
+			}
 			if (match_longopt("max-mem"))
 			{
 				if (at_end() || next_is_opt()) error_exit("error: --max-mem needs a valid integer.");
@@ -1160,6 +1166,7 @@ BuildOptions parse_arguments(int argc, const char *argv[])
 		.link_libc = LINK_LIBC_NOT_SET,
 		.use_stdlib = USE_STDLIB_NOT_SET,
 		.linker_type = LINKER_TYPE_NOT_SET,
+		.warning_level = WARNING_NOT_SET,
 		.strip_unused = STRIP_UNUSED_NOT_SET,
 		.single_module = SINGLE_MODULE_NOT_SET,
 		.sanitize_mode = SANITIZE_NOT_SET,
diff --git a/src/build/builder.c b/src/build/builder.c
index 5a597167e..cbd705185 100644
--- a/src/build/builder.c
+++ b/src/build/builder.c
@@ -354,6 +354,7 @@ static void update_build_target_from_options(BuildTarget *target, BuildOptions *
 	if (options->merge_functions != MERGE_FUNCTIONS_NOT_SET) target->merge_functions = options->merge_functions;
 	if (options->loop_vectorization != VECTORIZATION_NOT_SET) target->loop_vectorization = options->loop_vectorization;
 	if (options->slp_vectorization != VECTORIZATION_NOT_SET) target->slp_vectorization = options->slp_vectorization;
+	if (options->warning_level != WARNING_NORMAL) target->warning_level = options->warning_level;
 	if (options->safety_level != SAFETY_NOT_SET) target->feature.safe_mode = options->safety_level;
 	if (options->panic_level != PANIC_NOT_SET) target->feature.panic_level = options->panic_level;
 	if (options->strip_unused != STRIP_UNUSED_NOT_SET) target->strip_unused = options->strip_unused;
diff --git a/src/compiler/compiler_internal.h b/src/compiler/compiler_internal.h
index 6bb5c9e42..2b51a57d5 100644
--- a/src/compiler/compiler_internal.h
+++ b/src/compiler/compiler_internal.h
@@ -2359,6 +2359,7 @@ void print_error_at(SourceSpan loc, const char *message, ...);
 void print_error_after(SourceSpan loc, const char *message, ...);
 void sema_note_prev_at(SourceSpan loc, const char *message, ...);
 void sema_verror_range(SourceSpan location, const char *message, va_list args);
+void sema_vwarn_range(SourceSpan location, const char *message, va_list args);
 void print_error(ParseContext *context, const char *message, ...);
 
 void sema_warning_at(SourceSpan loc, const char *message, ...);
diff --git a/src/compiler/diagnostics.c b/src/compiler/diagnostics.c
index a71aa8077..0b1aeea95 100644
--- a/src/compiler/diagnostics.c
+++ b/src/compiler/diagnostics.c
@@ -146,18 +146,23 @@ static void print_error_type_at(SourceSpan location, const char *message, PrintT
 
 }
 
-static void vprint_error(SourceSpan location, const char *message, va_list args)
+static void vprint_msg(SourceSpan location, const char *message, va_list args, PrintType type)
 {
-	print_error_type_at(location, str_vprintf(message, args), PRINT_TYPE_ERROR);
+	print_error_type_at(location, str_vprintf(message, args), type);
 }
 
 
 void sema_verror_range(SourceSpan location, const char *message, va_list args)
 {
-	vprint_error(location, message, args);
+	vprint_msg(location, message, args, PRINT_TYPE_ERROR);
 	compiler.context.errors_found++;
 }
 
+void sema_vwarn_range(SourceSpan location, const char *message, va_list args)
+{
+	vprint_msg(location, message, args, PRINT_TYPE_WARN);
+}
+
 void sema_warning_at(SourceSpan loc, const char *message, ...)
 {
 	va_list list;
@@ -202,6 +207,22 @@ void sema_note_prev_at(SourceSpan loc, const char *message, ...)
 }
 
 
+void sema_warn_prev_at(SourceSpan loc, const char *message, ...)
+{
+	va_list args;
+	va_start(args, message);
+#define MAX_ERROR_LEN 4096
+	char buffer[MAX_ERROR_LEN];
+	size_t written = vsnprintf(buffer, MAX_ERROR_LEN - 1, message, args);
+	// Ignore errors
+	if (written <= MAX_ERROR_LEN - 2)
+	{
+		print_error_type_at(loc, buffer, PRINT_TYPE_WARN);
+	}
+	va_end(args);
+	return;
+}
+
 void print_error(ParseContext *context, const char *message, ...)
 {
 	compiler.context.errors_found++;
diff --git a/src/compiler/llvm_codegen_internal_impl.h b/src/compiler/llvm_codegen_internal_impl.h
index 3f944a2fc..c5c10e2e1 100644
--- a/src/compiler/llvm_codegen_internal_impl.h
+++ b/src/compiler/llvm_codegen_internal_impl.h
@@ -357,6 +357,7 @@ INLINE void llvm_emit_statement_chain(GenContext *c, AstId current)
 {
 	while (current)
 	{
+
 		llvm_emit_stmt(c, ast_next(&current));
 	}
 }
diff --git a/src/compiler/llvm_codegen_stmt.c b/src/compiler/llvm_codegen_stmt.c
index 25f1869a3..b07cb4d72 100644
--- a/src/compiler/llvm_codegen_stmt.c
+++ b/src/compiler/llvm_codegen_stmt.c
@@ -1605,6 +1605,7 @@ void llvm_emit_panic_on_true(GenContext *c, LLVMValueRef value, const char *pani
 
 void llvm_emit_stmt(GenContext *c, Ast *ast)
 {
+	if (!c->current_block) return;
 	if (ast->ast_kind != AST_COMPOUND_STMT) EMIT_LOC(c, ast);
 	switch (ast->ast_kind)
 	{
diff --git a/src/compiler/parse_expr.c b/src/compiler/parse_expr.c
index a00890add..acaa8fe67 100644
--- a/src/compiler/parse_expr.c
+++ b/src/compiler/parse_expr.c
@@ -1351,6 +1351,10 @@ static Expr *parse_identifier_starting_expression(ParseContext *c, Expr *left)
 		{
 			Expr *expr = parse_identifier(c, NULL);
 			expr->identifier_expr.path = path;
+			if (path)
+			{
+				expr->span = extend_span_with_token(path->span, expr->span);
+			}
 			return expr;
 		}
 		case TOKEN_TYPE_IDENT:
diff --git a/src/compiler/parse_stmt.c b/src/compiler/parse_stmt.c
index 48e8c115c..ef464215b 100644
--- a/src/compiler/parse_stmt.c
+++ b/src/compiler/parse_stmt.c
@@ -37,7 +37,7 @@ static Ast *parse_decl_stmt_after_type(ParseContext *c, TypeInfo *type)
 			}
 			break;
 		case TOKEN_EOS:
-			return ast;
+			goto DONE;
 		default:
 			break;
 	}
@@ -58,8 +58,7 @@ static Ast *parse_decl_stmt_after_type(ParseContext *c, TypeInfo *type)
 				return poisoned_ast;
 			}
 		}
-		RANGE_EXTEND_PREV(ast);
-		return ast;
+		goto DONE;
 	}
 	Decl **decls = NULL;
 	vec_add(decls, decl);
@@ -94,6 +93,7 @@ static Ast *parse_decl_stmt_after_type(ParseContext *c, TypeInfo *type)
 	}
 	ast->decls_stmt = decls;
 	ast->ast_kind = AST_DECLS_STMT;
+DONE:
 	RANGE_EXTEND_PREV(ast);
 	return ast;
 
diff --git a/src/compiler/sema_internal.h b/src/compiler/sema_internal.h
index 21e8aed68..c1e3dd9c8 100644
--- a/src/compiler/sema_internal.h
+++ b/src/compiler/sema_internal.h
@@ -17,6 +17,7 @@
 #define UINT12_MAX        4095
 #define UINT20_MAX        1048575U
 
+#define SEMA_WARN(_node, ...) (sema_warn_at(context, (_node)->span, __VA_ARGS__))
 #define SEMA_ERROR(_node, ...) sema_error_at(context, (_node)->span, __VA_ARGS__)
 #define RETURN_SEMA_ERROR(_node, ...) do { sema_error_at(context, (_node)->span, __VA_ARGS__); return false; } while (0)
 #define RETURN_SEMA_ERROR_AT(span__, ...) do { sema_error_at(context, span__, __VA_ARGS__); return false; } while (0)
@@ -60,6 +61,7 @@ SemaContext *context_transform_for_eval(SemaContext *context, SemaContext *temp_
 TokenType sema_splitpathref(const char *string, ArraySize len, Path **path_ref, const char **ident_ref);
 void sema_print_inline(SemaContext *context);
 void sema_error_at(SemaContext *context, SourceSpan span, const char *message, ...);
+bool sema_warn_at(SemaContext *context, SourceSpan span, const char *message, ...);
 
 void sema_context_init(SemaContext *context, CompilationUnit *unit);
 void sema_context_destroy(SemaContext *context);
diff --git a/src/compiler/sema_stmts.c b/src/compiler/sema_stmts.c
index 0d0a37a1b..a8851fa4a 100644
--- a/src/compiler/sema_stmts.c
+++ b/src/compiler/sema_stmts.c
@@ -1841,8 +1841,10 @@ static inline bool sema_analyse_if_stmt(SemaContext *context, Ast *statement)
 		}
 		if (context->active_scope.jump_end && !context->active_scope.allow_dead_code)
 		{
-			SEMA_ERROR(then, "This code can never be executed.");
-			success = false;
+			if (!SEMA_WARN(then, "This code will never execute."))
+			{
+				success = false;
+			}
 		}
 
 		if (then->ast_kind == AST_IF_CATCH_SWITCH_STMT)
@@ -3048,8 +3050,10 @@ bool sema_analyse_statement(SemaContext *context, Ast *statement)
 			// If we start with an don't start with an assert AND the scope is a macro, then it's bad.
 			if (statement->ast_kind != AST_ASSERT_STMT && statement->ast_kind != AST_NOP_STMT && !(context->active_scope.flags & SCOPE_MACRO))
 			{
-				SEMA_ERROR(statement, "This code will never execute.");
-				return ast_poison(statement);
+				if (!SEMA_WARN(statement, "This code will never execute."))
+				{
+					return ast_poison(statement);
+				}
 			}
 			// Remove it
 			statement->ast_kind = AST_NOP_STMT;
diff --git a/src/compiler/semantic_analyser.c b/src/compiler/semantic_analyser.c
index 59b4cda2c..612cfe1a2 100644
--- a/src/compiler/semantic_analyser.c
+++ b/src/compiler/semantic_analyser.c
@@ -552,3 +552,21 @@ void sema_error_at(SemaContext *context, SourceSpan span, const char *message, .
 	va_end(list);
 	sema_print_inline(context);
 }
+
+bool sema_warn_at(SemaContext *context, SourceSpan span, const char *message, ...)
+{
+	bool is_warn = compiler.build.warning_level < WARNING_ERROR;
+	va_list list;
+	va_start(list, message);
+	if (is_warn)
+	{
+		sema_vwarn_range(span, message, list);
+	}
+	else
+	{
+		sema_verror_range(span, message, list);
+	}
+	va_end(list);
+	sema_print_inline(context);
+	return is_warn;
+}
diff --git a/test/src/tester.py b/test/src/tester.py
index d60e508ba..803f5250f 100644
--- a/test/src/tester.py
+++ b/test/src/tester.py
@@ -115,6 +115,14 @@ class Issues:
 				pos = key.split(":", 2)
 				print(str(num) + ". " + pos[0] + " line: " + pos[1] + " expected: \"" + value + "\"")
 				num += 1
+		if len(self.warnings) > 0:
+			self.set_failed()
+			print("Expected warnings that never occurred:")
+			num = 1
+			for key, value in self.warnings.items():
+				pos = key.split(":", 2)
+				print(str(num) + ". " + pos[0] + " line: " + pos[1] + " expected: \"" + value + "\"")
+				num += 1
 
 	def compile(self, args):
 		os.chdir(TEST_DIR)
@@ -193,8 +201,8 @@ class Issues:
 	def parse_trailing_directive(self, line):
 		line = line.split('// #', 2)[1].strip()
 		if line.startswith("warning:"):
-			print("TODO" + line)
-			exit(-1)
+			line = line[8:].strip()
+			self.warnings[self.current_file.filename + ":%d" % (self.line + self.current_file.line_offset)] = line
 		elif line.startswith("target:"):
 			self.arch = line[7:].strip()
 		elif line.startswith("error:"):
diff --git a/test/test_suite/functions/double_return.c3 b/test/test_suite/functions/double_return.c3
index 35dfc0786..29ea27780 100644
--- a/test/test_suite/functions/double_return.c3
+++ b/test/test_suite/functions/double_return.c3
@@ -3,6 +3,6 @@ module double_return;
 fn int test(bool pos, bool color)
 {
   return 0;
-  return (int)(pos && color); // #error: never execute
+  return (int)(pos && color); // #warning: never execute
 }
 
diff --git a/test/test_suite/statements/return_with_other_at_end.c3 b/test/test_suite/statements/return_with_other_at_end.c3
index 5dc093294..a18b63709 100644
--- a/test/test_suite/statements/return_with_other_at_end.c3
+++ b/test/test_suite/statements/return_with_other_at_end.c3
@@ -2,6 +2,6 @@ fn int testReturnWithOtherAtEnd()
 {
     int i = 0;
     return i;
-    if (i == 10) i++; // #error: This code will
+    if (i == 10) i++; // #warning: This code will
     i = i + 2;
 }