Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 4b1be68be8224f2e1d526978d996416c7cc19918)
+++ src/Concurrency/Keywords.cc	(revision a16764a6fbfe44300fc8834400a31c89befda091)
@@ -280,5 +280,5 @@
 		if( ! decl->body ) return;
 
-		if( !type_decl ) throw SemanticError( decl, context_error );
+		if( !type_decl ) SemanticError( decl, context_error );
 
 		FunctionDecl * func = forwardDeclare( decl );
@@ -417,9 +417,9 @@
 		if( mutexArgs.empty() ) return;
 
-		if( CodeGen::isConstructor(decl->name) ) throw SemanticError( decl, "constructors cannot have mutex parameters" );
+		if( CodeGen::isConstructor(decl->name) ) SemanticError( decl, "constructors cannot have mutex parameters" );
 
 		bool isDtor = CodeGen::isDestructor( decl->name );
 
-		if( isDtor && mutexArgs.size() != 1 ) throw SemanticError( decl, "destructors can only have 1 mutex argument" );
+		if( isDtor && mutexArgs.size() != 1 ) SemanticError( decl, "destructors can only have 1 mutex argument" );
 
 		for(auto arg : mutexArgs) {
@@ -430,7 +430,6 @@
 		if( ! body ) return;
 
-		if( !monitor_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
-		if( !guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
-		if( !dtor_guard_decl ) throw SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
+		if( !monitor_decl || !guard_decl || !dtor_guard_decl )
+			SemanticError( decl, "mutex keyword requires monitors to be in scope, add #include <monitor>" );
 
 		if( isDtor ) {
@@ -478,13 +477,13 @@
 		//Makes sure it's not a copy
 		ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
-		if( ! rty ) throw SemanticError( arg, "Mutex argument must be of reference type " );
+		if( ! rty ) SemanticError( arg, "Mutex argument must be of reference type " );
 
 		//Make sure the we are pointing directly to a type
 		Type* base = rty->get_base();
-		if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
-		if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+		if( dynamic_cast< ReferenceType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
+		if( dynamic_cast< PointerType * >( base ) ) SemanticError( arg, "Mutex argument have exactly one level of indirection " );
 
 		//Make sure that typed isn't mutex
-		if( base->get_mutex() ) throw SemanticError( arg, "mutex keyword may only appear once per argument " );
+		if( base->get_mutex() ) SemanticError( arg, "mutex keyword may only appear once per argument " );
 	}
 
@@ -624,5 +623,5 @@
 		if( type && type->get_baseStruct()->is_thread() ) {
 			if( !thread_decl || !thread_ctor_seen ) {
-				throw SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
+				SemanticError( type->get_baseStruct()->location, "thread keyword requires threads to be in scope, add #include <thread>");
 			}
 
Index: src/Concurrency/Waitfor.cc
===================================================================
--- src/Concurrency/Waitfor.cc	(revision 4b1be68be8224f2e1d526978d996416c7cc19918)
+++ src/Concurrency/Waitfor.cc	(revision a16764a6fbfe44300fc8834400a31c89befda091)
@@ -250,5 +250,5 @@
 	Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) {
 		if( !decl_monitor || !decl_acceptable || !decl_mask )
-			throw SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" );
+			SemanticError( waitfor, "waitfor keyword requires monitors to be in scope, add #include <monitor>" );
 
 		CompoundStmt * stmt = new CompoundStmt();