Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12)
+++ src/SymTab/Indexer.cc	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
@@ -388,5 +388,5 @@
 			if ( newentry && oldentry ) {
 				if ( newentry->get_statements() && oldentry->get_statements() ) {
-					throw SemanticError( "duplicate function definition for ", added );
+					throw SemanticError( added, "duplicate function definition for " );
 				} // if
 			} else {
@@ -398,9 +398,9 @@
 				ObjectDecl *oldobj = dynamic_cast< ObjectDecl* >( existing );
 				if ( ! newobj->get_storageClasses().is_extern && ! oldobj->get_storageClasses().is_extern ) {
-					throw SemanticError( "duplicate object definition for ", added );
+					throw SemanticError( added, "duplicate object definition for " );
 				} // if
 			} // if
 		} else {
-			throw SemanticError( "duplicate definition for ", added );
+			throw SemanticError( added, "duplicate definition for " );
 		} // if
 
@@ -431,10 +431,10 @@
 			// isomorphic to C type-compatibility, which it may not be.
 			if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
-				throw SemanticError( "conflicting overload of C function ", decl );
+				throw SemanticError( decl, "conflicting overload of C function " );
 			}
 		} else {
 			// Check that a Cforall declaration doesn't overload any C declaration
 			if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-				throw SemanticError( "Cforall declaration hides C function ", decl );
+				throw SemanticError( decl, "Cforall declaration hides C function " );
 			}
 		}
@@ -455,5 +455,5 @@
 			return true;
 		} else {
-			throw SemanticError( "redeclaration of ", added );
+			throw SemanticError( added, "redeclaration of " );
 		}
 	}
@@ -482,5 +482,5 @@
 			return false;
 		} else if ( ! added->get_members().empty() ) {
-			throw SemanticError( "redeclaration of ", added );
+			throw SemanticError( added, "redeclaration of " );
 		} // if
 		return true;
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12)
+++ src/SymTab/Validate.cc	(revision c2ca04d9fcb38436d3cecb12ea970191dac218ab)
@@ -366,5 +366,5 @@
 				dwts.erase( j );
 				if ( i != end ) {
-					throw SemanticError( "invalid type void in function type ", func );
+					throw SemanticError( func, "invalid type void in function type " );
 				} // if
 			} else {
@@ -374,5 +374,5 @@
 					*i = (*i)->acceptMutator( fixer );
 					if ( fixer.pass.isVoid ) {
-						throw SemanticError( "invalid type void in function type ", func );
+						throw SemanticError( func, "invalid type void in function type " );
 					} // if
 				} // for
@@ -411,5 +411,5 @@
 		for ( Expression * param : inst->parameters ) {
 			if ( ! dynamic_cast< TypeExpr * >( param ) ) {
-				throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst );
+				throw SemanticError( inst, "Expression parameters for generic types are currently unsupported: " );
 			}
 		}
@@ -511,8 +511,8 @@
 		TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
 		if ( ! traitDecl ) {
-			throw SemanticError( "use of undeclared trait " + traitInst->name );
+			throw SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
 		} // if
 		if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
-			throw SemanticError( "incorrect number of trait parameters: ", traitInst );
+			throw SemanticError( traitInst, "incorrect number of trait parameters: " );
 		} // if
 		traitInst->baseTrait = traitDecl;
@@ -522,5 +522,5 @@
 			TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
 			if ( ! expr ) {
-				throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p) );
+				throw SemanticError( std::get<1>(p), "Expression parameters for trait instances are currently unsupported: " );
 			}
 			if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
@@ -629,5 +629,5 @@
 				assertion = assertion->acceptMutator( fixer );
 				if ( fixer.pass.isVoid ) {
-					throw SemanticError( "invalid type void in assertion of function ", node );
+					throw SemanticError( node, "invalid type void in assertion of function " );
 				} // if
 			} // for
@@ -673,5 +673,5 @@
 		// were cast to void.
 		if ( ! returnStmt->get_expr() && returnVals.size() != 0 ) {
-			throw SemanticError( "Non-void function returns no values: " , returnStmt );
+			throw SemanticError( returnStmt, "Non-void function returns no values: " );
 		}
 	}
@@ -714,5 +714,5 @@
 				ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
 				if ( ! rtt ) {
-					throw SemanticError("Cannot apply type parameters to base type of " + typeInst->name);
+					throw SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
 				}
 				rtt->get_parameters().clear();
@@ -752,5 +752,5 @@
 			Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
 			if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
-				throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+				throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
 			}
 			// Cannot redefine VLA typedefs. Note: this is slightly incorrect, because our notion of VLAs
@@ -759,5 +759,5 @@
 			// to fix this corner case likely outweighs the utility of allowing it.
 			if ( isVariableLength( t1 ) || isVariableLength( t2 ) ) {
-				throw SemanticError( "Cannot redefine typedef: " + tyDecl->name );
+				throw SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
 			}
 		} else {
@@ -908,12 +908,12 @@
 		if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
 			if ( params.size() == 0 ) {
-				throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
+				throw SemanticError( funcDecl, "Constructors, destructors, and assignment functions require at least one parameter " );
 			}
 			ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
 			if ( ! refType ) {
-				throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl );
+				throw SemanticError( funcDecl, "First parameter of a constructor, destructor, or assignment function must be a reference " );
 			}
 			if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
-				throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+				throw SemanticError( funcDecl, "Constructors and destructors cannot have explicit return values " );
 			}
 		}
@@ -950,6 +950,6 @@
 
 			sub.apply( inst );
-			if ( args.size() < params->size() ) throw SemanticError( "Too few type arguments in generic type ", inst );
-			if ( args.size() > params->size() ) throw SemanticError( "Too many type arguments in generic type ", inst );
+			if ( args.size() < params->size() ) throw SemanticError( inst, "Too few type arguments in generic type " );
+			if ( args.size() > params->size() ) throw SemanticError( inst, "Too many type arguments in generic type " );
 		}
 	}