Index: src/Concurrency/Waitfor.cc
===================================================================
--- src/Concurrency/Waitfor.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/Concurrency/Waitfor.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -228,8 +228,8 @@
 			decl_acceptable = decl;
 			for( Declaration * field : decl_acceptable->members ) {
-				     if( field->name == "func"    ) decl_m_func     = safe_dynamic_cast< DeclarationWithType * >( field );
-				else if( field->name == "count"   ) decl_m_count    = safe_dynamic_cast< DeclarationWithType * >( field );
-				else if( field->name == "monitor" ) decl_m_monitors = safe_dynamic_cast< DeclarationWithType * >( field );
-				else if( field->name == "is_dtor" ) decl_m_isdtor   = safe_dynamic_cast< DeclarationWithType * >( field );
+				     if( field->name == "func"    ) decl_m_func     = strict_dynamic_cast< DeclarationWithType * >( field );
+				else if( field->name == "count"   ) decl_m_count    = strict_dynamic_cast< DeclarationWithType * >( field );
+				else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field );
+				else if( field->name == "is_dtor" ) decl_m_isdtor   = strict_dynamic_cast< DeclarationWithType * >( field );
 			}
 
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/GenPoly/Box.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -15,5 +15,5 @@
 
 #include <algorithm>                     // for mismatch
-#include <cassert>                       // for assert, safe_dynamic_cast
+#include <cassert>                       // for assert, strict_dynamic_cast
 #include <iostream>                      // for operator<<, stringstream
 #include <list>                          // for list, list<>::iterator, _Lis...
@@ -1299,5 +1299,5 @@
 
 		DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
-			functionDecl = safe_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
+			functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
 			FunctionType * ftype = functionDecl->get_functionType();
 			if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1378,5 +1378,5 @@
 			// move polymorphic return type to parameter list
 			if ( isDynRet( funcType ) ) {
-				ObjectDecl *ret = safe_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
+				ObjectDecl *ret = strict_dynamic_cast< ObjectDecl* >( funcType->get_returnVals().front() );
 				ret->set_type( new PointerType( Type::Qualifiers(), ret->get_type() ) );
 				funcType->get_parameters().push_front( ret );
Index: src/GenPoly/InstantiateGeneric.cc
===================================================================
--- src/GenPoly/InstantiateGeneric.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/GenPoly/InstantiateGeneric.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -459,5 +459,5 @@
 			Declaration * member = *std::next( aggr->members.begin(), memberIndex );
 			assertf( member->name == memberExpr->member->name, "Instantiation has different member order than the generic type. %s / %s", toString( member ).c_str(), toString( memberExpr->member ).c_str() );
-			DeclarationWithType * field = safe_dynamic_cast< DeclarationWithType * >( member );
+			DeclarationWithType * field = strict_dynamic_cast< DeclarationWithType * >( member );
 			MemberExpr * ret = new MemberExpr( field, memberExpr->aggregate->clone() );
 			std::swap( ret->env, memberExpr->env );
Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/GenPoly/Lvalue.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>                       // for safe_dynamic_cast
+#include <cassert>                       // for strict_dynamic_cast
 #include <string>                        // for string
 
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/InitTweak/FixInit.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -17,5 +17,5 @@
 #include <stddef.h>                    // for NULL
 #include <algorithm>                   // for set_difference, copy_if
-#include <cassert>                     // for assert, safe_dynamic_cast
+#include <cassert>                     // for assert, strict_dynamic_cast
 #include <iostream>                    // for operator<<, ostream, basic_ost...
 #include <iterator>                    // for insert_iterator, back_inserter
@@ -424,5 +424,5 @@
 			// arrays are not copy constructed, so this should always be an ExprStmt
 			ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
-			ExprStmt * exprStmt = safe_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+			ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
 			Expression * untyped = exprStmt->get_expr();
 
@@ -532,5 +532,5 @@
 				assert( ! body->get_kids().empty() );
 				// must be an ExprStmt, otherwise it wouldn't have a result
-				ExprStmt * last = safe_dynamic_cast< ExprStmt * >( body->get_kids().back() );
+				ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
 				last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
 
@@ -566,5 +566,5 @@
 			CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
-			impCpCtorExpr = safe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
+			impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
 			std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
 			std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -627,5 +627,5 @@
 				stmt = stmt->acceptMutator( *this );
 			} // for
-			// stmtExpr = safe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
+			// stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
 			assert( stmtExpr->get_result() );
 			Type * result = stmtExpr->get_result();
@@ -791,5 +791,5 @@
 						}
 					} else {
-						ImplicitCtorDtorStmt * implicit = safe_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
+						ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
 						ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
 						ApplicationExpr * ctorCall = nullptr;
@@ -996,5 +996,5 @@
 				FunctionType * type = function->get_functionType();
 				assert( ! type->get_parameters().empty() );
-				thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
+				thisParam = strict_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
 				Type * thisType = getPointerBase( thisParam->get_type() );
 				StructInstType * structType = dynamic_cast< StructInstType * >( thisType );
@@ -1166,5 +1166,5 @@
 
 		Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-			return safe_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+			return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
 		}
 
@@ -1179,5 +1179,5 @@
 
 			// xxx - this can be TupleAssignExpr now. Need to properly handle this case.
-			ApplicationExpr * callExpr = safe_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
+			ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
 			TypeSubstitution * env = ctorExpr->get_env();
 			ctorExpr->set_callExpr( nullptr );
Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/InitTweak/GenInit.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -17,5 +17,5 @@
 #include <stddef.h>                // for NULL
 #include <algorithm>               // for any_of
-#include <cassert>                 // for assert, safe_dynamic_cast, assertf
+#include <cassert>                 // for assert, strict_dynamic_cast, assertf
 #include <iterator>                // for back_inserter, inserter, back_inse...
 #include <list>                    // for _List_iterator, list
@@ -255,5 +255,5 @@
 		SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl );
 		assert( stmts.size() <= 1 );
-		return stmts.size() == 1 ? safe_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+		return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
 	}
 
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/InitTweak/InitTweak.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -1,5 +1,5 @@
 #include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
-#include <cassert>                 // for assertf, assert, safe_dynamic_cast
+#include <cassert>                 // for assertf, assert, strict_dynamic_cast
 #include <iostream>                // for ostream, cerr, endl
 #include <iterator>                // for back_insert_iterator, back_inserter
@@ -414,6 +414,6 @@
 			std::list< Statement * > & stmts = tupleExpr->get_stmtExpr()->get_statements()->get_kids();
 			assertf( ! stmts.empty(), "TupleAssignExpr somehow has no statements." );
-			ExprStmt * stmt = safe_dynamic_cast< ExprStmt * >( stmts.back() );
-			TupleExpr * tuple = safe_dynamic_cast< TupleExpr * >( stmt->get_expr() );
+			ExprStmt * stmt = strict_dynamic_cast< ExprStmt * >( stmts.back() );
+			TupleExpr * tuple = strict_dynamic_cast< TupleExpr * >( stmt->get_expr() );
 			assertf( ! tuple->get_exprs().empty(), "TupleAssignExpr somehow has empty tuple expr." );
 			return getCallArg( tuple->get_exprs().front(), pos );
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/Parser/DeclarationNode.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>                 // for assert, assertf, safe_dynamic_cast
+#include <cassert>                 // for assert, assertf, strict_dynamic_cast
 #include <iterator>                // for back_insert_iterator
 #include <list>                    // for list
@@ -1027,5 +1027,5 @@
 
 	if ( asmStmt ) {
-		return new AsmDecl( safe_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
+		return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
 	} // if
 
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/Parser/StatementNode.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>                 // for assert, safe_dynamic_cast, assertf
+#include <cassert>                 // for assert, strict_dynamic_cast, assertf
 #include <list>                    // for list
 #include <memory>                  // for unique_ptr
@@ -57,5 +57,5 @@
 	// find end of list and maintain previous pointer
 	for ( StatementNode * curr = prev; curr != nullptr; curr = (StatementNode *)curr->get_next() ) {
-		StatementNode *node = safe_dynamic_cast< StatementNode * >(curr);
+		StatementNode *node = strict_dynamic_cast< StatementNode * >(curr);
 		assert( dynamic_cast< CaseStmt * >(node->stmt.get()) );
 		prev = curr;
@@ -106,6 +106,6 @@
 		for ( Statement * stmt : init ) {
 			// build the && of all of the declared variables compared against 0
-			DeclStmt * declStmt = safe_dynamic_cast< DeclStmt * >( stmt );
-			DeclarationWithType * dwt = safe_dynamic_cast< DeclarationWithType * >( declStmt->decl );
+			DeclStmt * declStmt = strict_dynamic_cast< DeclStmt * >( stmt );
+			DeclarationWithType * dwt = strict_dynamic_cast< DeclarationWithType * >( declStmt->decl );
 			Expression * nze = notZeroExpr( new VariableExpr( dwt ) );
 			cond = cond ? new LogicalExpr( cond, nze, true ) : nze;
@@ -202,5 +202,5 @@
 	std::list< CatchStmt * > branches;
 	buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
-	CompoundStmt *tryBlock = safe_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
+	CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
 	FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
 	return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -15,5 +15,5 @@
 
 #include <algorithm>               // for copy
-#include <cassert>                 // for safe_dynamic_cast, assert, assertf
+#include <cassert>                 // for strict_dynamic_cast, assert, assertf
 #include <iostream>                // for operator<<, cerr, ostream, endl
 #include <iterator>                // for back_insert_iterator, back_inserter
@@ -336,7 +336,7 @@
 
 	Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
-		ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
-		PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-		FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+		ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( alt.expr );
+		PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+		FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
 
 		Cost convCost = Cost::zero;
@@ -494,5 +494,5 @@
 			Cost cost = Cost::zero;
 			std::list< Expression * > newExprs;
-			ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
+			ObjectDecl * obj = strict_dynamic_cast< ObjectDecl * >( formal );
 			if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
 				deleteAll( newExprs );
@@ -787,7 +787,7 @@
 
 			PRINT(
-				ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
-				PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-				FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+				ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr );
+				PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+				FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
 				std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
 				std::cerr << "formals are:" << std::endl;
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/ResolvExpr/CommonType.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>                       // for safe_dynamic_cast
+#include <cassert>                       // for strict_dynamic_cast
 #include <map>                           // for _Rb_tree_const_iterator
 #include <utility>                       // for pair
@@ -100,7 +100,7 @@
 			// special case where one type has a reference depth of 1 larger than the other
 			if ( diff > 0 ) {
-				return handleReference( safe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
+				return handleReference( strict_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
 			} else if ( diff < 0 ) {
-				return handleReference( safe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+				return handleReference( strict_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
 			}
 			// otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
@@ -114,5 +114,5 @@
 				if ( TypeInstType *inst = dynamic_cast< TypeInstType* >( type2 ) ) {
 					if ( NamedTypeDecl *nt = indexer.lookupType( inst->get_name() ) ) {
-						TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+						TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
 						if ( type->get_base() ) {
 							Type::Qualifiers tq1 = type1->get_qualifiers(), tq2 = type2->get_qualifiers();
@@ -301,5 +301,5 @@
 			NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
 			if ( nt ) {
-				TypeDecl *type = safe_dynamic_cast< TypeDecl* >( nt );
+				TypeDecl *type = strict_dynamic_cast< TypeDecl* >( nt );
 				if ( type->get_base() ) {
 					Type::Qualifiers tq1 = inst->get_qualifiers(), tq2 = type2->get_qualifiers();
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/ResolvExpr/ConversionCost.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -95,10 +95,10 @@
 		if ( diff > 0 ) {
 			// TODO: document this
-			Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+			Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
 			cost.incReference();
 			return cost;
 		} else if ( diff < -1 ) {
 			// TODO: document this
-			Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+			Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
 			cost.incReference();
 			return cost;
Index: src/ResolvExpr/CurrentObject.cc
===================================================================
--- src/ResolvExpr/CurrentObject.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/ResolvExpr/CurrentObject.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -286,5 +286,5 @@
 				for ( InitAlternative & alt : ret ) {
 					PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-					alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+					alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
 					// need to substitute for generic types, so that casts are to concrete types
 					PRINT( std::cerr << "  type is: " << alt.type; )
@@ -346,5 +346,5 @@
 				for ( InitAlternative & alt : ret ) {
 					PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-					alt.designation->get_designators().push_front( new VariableExpr( safe_dynamic_cast< ObjectDecl * >( *curMember ) ) );
+					alt.designation->get_designators().push_front( new VariableExpr( strict_dynamic_cast< ObjectDecl * >( *curMember ) ) );
 				}
 			}
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/ResolvExpr/Resolver.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -15,5 +15,5 @@
 
 #include <stddef.h>                      // for NULL
-#include <cassert>                       // for safe_dynamic_cast, assert
+#include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
@@ -342,5 +342,5 @@
 			CastExpr * castExpr = new CastExpr( caseStmt->get_condition(), initAlts.front().type->clone() );
 			Expression * newExpr = findSingleExpression( castExpr, *this );
-			castExpr = safe_dynamic_cast< CastExpr * >( newExpr );
+			castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
 			caseStmt->set_condition( castExpr->get_arg() );
 			castExpr->set_arg( nullptr );
@@ -398,5 +398,5 @@
 		Parent::enterScope();
 		Visitor::visit( catchStmt );
-		
+
 		if ( catchStmt->get_cond() ) {
 			Expression * wrapped = new CastExpr(
@@ -423,5 +423,5 @@
 		UntypedInitExpr * untyped = new UntypedInitExpr( singleInit->get_value(), currentObject.getOptions() );
 		Expression * newExpr = findSingleExpression( untyped, *this );
-		InitExpr * initExpr = safe_dynamic_cast< InitExpr * >( newExpr );
+		InitExpr * initExpr = strict_dynamic_cast< InitExpr * >( newExpr );
 
 		// move cursor to the object that is actually initialized
@@ -445,5 +445,5 @@
 					if ( isCharType( pt->get_base() ) ) {
 						// strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
-						CastExpr *ce = safe_dynamic_cast< CastExpr * >( newExpr );
+						CastExpr *ce = strict_dynamic_cast< CastExpr * >( newExpr );
 						newExpr = ce->get_arg();
 						ce->set_arg( nullptr );
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SymTab/Autogen.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -18,5 +18,5 @@
 #include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
-#include <cassert>                 // for safe_dynamic_cast, assert, assertf
+#include <cassert>                 // for strict_dynamic_cast, assert, assertf
 #include <iterator>                // for back_insert_iterator, back_inserter
 #include <list>                    // for list, _List_iterator, list<>::iter...
@@ -250,6 +250,6 @@
 		// parameters) are using in the variable exprs
 		assert( ftype->get_parameters().size() == 2 );
-		ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
-		ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+		ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+		ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
 
 		VariableExpr * assignVarExpr = new VariableExpr( assignDecl );
@@ -307,5 +307,5 @@
 
 		// assign to destination
-		Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
+		Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), strict_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
 		genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
 	}
@@ -436,5 +436,5 @@
 				FunctionType * assignType = dcl->get_functionType();
 				assert( assignType->get_parameters().size() == 2 );
-				ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
+				ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( assignType->get_parameters().back() );
 				dcl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
 			}
@@ -487,6 +487,6 @@
 		FunctionType * ftype = funcDecl->get_functionType();
 		assert( ftype->get_parameters().size() == 2 );
-		ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
-		ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
+		ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
+		ObjectDecl * srcParam = strict_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
 
 		makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
@@ -700,5 +700,5 @@
 
 	Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
-		tupleType = safe_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
+		tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
 		std::string mangleName = SymTab::Mangler::mangleType( tupleType );
 		if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
@@ -768,5 +768,5 @@
 	CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
 		seenTuples.beginScope();
-		compoundStmt = safe_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
+		compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
 		seenTuples.endScope();
 		return compoundStmt;
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SymTab/Indexer.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -16,5 +16,5 @@
 #include "Indexer.h"
 
-#include <cassert>                 // for assert, safe_dynamic_cast
+#include <cassert>                 // for assert, strict_dynamic_cast
 #include <iostream>                // for operator<<, basic_ostream, ostream
 #include <string>                  // for string, operator<<, operator!=
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SymTab/Validate.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -486,5 +486,5 @@
 		std::list< DeclarationWithType * > asserts;
 		for ( Declaration * decl : inst->baseTrait->members ) {
-			asserts.push_back( safe_dynamic_cast<DeclarationWithType *>( decl->clone() ) );
+			asserts.push_back( strict_dynamic_cast<DeclarationWithType *>( decl->clone() ) );
 		}
 		// substitute trait decl parameters for instance parameters
@@ -530,5 +530,5 @@
 		// need to carry over the 'sized' status of each decl in the instance
 		for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
-			TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( std::get<1>(p) );
+			TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( std::get<1>(p) );
 			if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
 				TypeDecl * formalDecl = std::get<0>(p);
@@ -892,5 +892,5 @@
 			for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
 				if ( i < args.size() ) {
-					TypeExpr * expr = safe_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
+					TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
 					sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
 				} else if ( i == args.size() ) {
@@ -962,5 +962,5 @@
 		if ( retVals.size() > 1 ) {
 			// generate a single return parameter which is the tuple of all of the return values
-			TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
+			TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
 			// ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
 			ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
Index: src/SynTree/AddressExpr.cc
===================================================================
--- src/SynTree/AddressExpr.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/AddressExpr.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -47,5 +47,5 @@
 		} else {
 			// taking address of non-lvalue -- must be a reference, loses one layer of reference
-			ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() );
+			ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
 			set_result( addrType( refType->get_base() ) );
 		}
Index: src/SynTree/ApplicationExpr.cc
===================================================================
--- src/SynTree/ApplicationExpr.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/ApplicationExpr.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>               // for safe_dynamic_cast, assert
+#include <cassert>               // for strict_dynamic_cast, assert
 #include <list>                  // for list
 #include <map>                   // for _Rb_tree_const_iterator, map, map<>:...
@@ -50,6 +50,6 @@
 
 ApplicationExpr::ApplicationExpr( Expression *funcExpr, const std::list<Expression *> & args ) : function( funcExpr ), args( args ) {
-	PointerType *pointer = safe_dynamic_cast< PointerType* >( funcExpr->get_result() );
-	FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+	PointerType *pointer = strict_dynamic_cast< PointerType* >( funcExpr->get_result() );
+	FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
 
 	set_result( ResolvExpr::extractResultType( function ) );
Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/CompoundStmt.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>                    // for assert, safe_dynamic_cast
+#include <cassert>                    // for assert, strict_dynamic_cast
 #include <list>                       // for list, _List_const_iterator, lis...
 #include <ostream>                    // for operator<<, ostream, basic_ostream
@@ -52,7 +52,7 @@
 		Statement * origStmt = *origit++;
 		if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( s ) ) {
-			DeclStmt * origDeclStmt = safe_dynamic_cast< DeclStmt * >( origStmt );
+			DeclStmt * origDeclStmt = strict_dynamic_cast< DeclStmt * >( origStmt );
 			if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * > ( declStmt->get_decl() ) ) {
-				DeclarationWithType * origdwt = safe_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
+				DeclarationWithType * origdwt = strict_dynamic_cast< DeclarationWithType * > ( origDeclStmt->get_decl() );
 				assert( dwt->get_name() == origdwt->get_name() );
 				declMap[ origdwt ] = dwt;
Index: src/SynTree/Constant.cc
===================================================================
--- src/SynTree/Constant.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/Constant.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>   // for safe_dynamic_cast, assertf
+#include <cassert>   // for strict_dynamic_cast, assertf
 #include <iostream>  // for operator<<, ostream, basic_ostream
 #include <string>    // for to_string, string, char_traits, operator<<
@@ -58,10 +58,10 @@
 
 unsigned long long Constant::get_ival() const {
-	assertf( safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
+	assertf( strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve ival from non-integer constant." );
 	return val.ival;
 }
 
 double Constant::get_dval() const {
-	assertf( ! safe_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
+	assertf( ! strict_dynamic_cast<BasicType*>(type)->isInteger(), "Attempt to retrieve dval from integer constant." );
 	return val.dval;
 }
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/Declaration.h	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -156,5 +156,5 @@
 
 	Type * get_type() const { return type; }
-	virtual void set_type(Type * t) { type = safe_dynamic_cast< FunctionType* >( t ); }
+	virtual void set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
 
 	FunctionType * get_functionType() const { return type; }
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/SynTree/TupleExpr.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -14,5 +14,5 @@
 //
 
-#include <cassert>              // for assert, safe_dynamic_cast, assertf
+#include <cassert>              // for assert, strict_dynamic_cast, assertf
 #include <iterator>             // for next
 #include <list>                 // for list, _List_iterator
@@ -64,5 +64,5 @@
 
 TupleIndexExpr::TupleIndexExpr( Expression * tuple, unsigned int index ) : tuple( tuple ), index( index )  {
-	TupleType * type = safe_dynamic_cast< TupleType * >( tuple->get_result() );
+	TupleType * type = strict_dynamic_cast< TupleType * >( tuple->get_result() );
 	assertf( type->size() > index, "TupleIndexExpr index out of bounds: tuple size %d, requested index %d in expr %s", type->size(), index, toString( tuple ).c_str() );
 	set_result( (*std::next( type->get_types().begin(), index ))->clone() );
Index: src/Tuples/TupleExpansion.cc
===================================================================
--- src/Tuples/TupleExpansion.cc	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/Tuples/TupleExpansion.cc	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -168,5 +168,5 @@
 				// steal the already generated assignment to var from the unqExpr - this has been generated by FixInit
 				Expression * expr = unqExpr->get_expr();
-				CommaExpr * commaExpr = safe_dynamic_cast< CommaExpr * >( expr );
+				CommaExpr * commaExpr = strict_dynamic_cast< CommaExpr * >( expr );
 				assignUnq = commaExpr->get_arg1();
 				commaExpr->set_arg1( nullptr );
@@ -237,9 +237,9 @@
 		delete tupleExpr;
 
-		StructInstType * type = safe_dynamic_cast< StructInstType * >( tuple->get_result() );
+		StructInstType * type = strict_dynamic_cast< StructInstType * >( tuple->get_result() );
 		StructDecl * structDecl = type->get_baseStruct();
 		assert( structDecl->get_members().size() > idx );
 		Declaration * member = *std::next(structDecl->get_members().begin(), idx);
-		MemberExpr * memExpr = new MemberExpr( safe_dynamic_cast< DeclarationWithType * >( member ), tuple );
+		MemberExpr * memExpr = new MemberExpr( strict_dynamic_cast< DeclarationWithType * >( member ), tuple );
 		memExpr->set_env( env );
 		return memExpr;
Index: src/include/cassert
===================================================================
--- src/include/cassert	(revision 9f5ecf510cb2c5f79c8536c82b1557eba39e1651)
+++ src/include/cassert	(revision e3e16bcf91a7300a6d1f71eaad04e2f3f498cfc2)
@@ -31,7 +31,7 @@
 	__ASSERT_FUNCTION, fmt, ## __VA_ARGS__ ))
 
-void __assert_fail_f( 	const char *assertion, const char *file, 
-						unsigned int line, const char *function, 
-						const char *fmt, ... 
+void __assert_fail_f( 	const char *assertion, const char *file,
+						unsigned int line, const char *function,
+						const char *fmt, ...
 	) __attribute__((noreturn, format(printf, 5, 6)));
 
@@ -39,5 +39,5 @@
 
 template<typename T, typename U>
-static inline T safe_dynamic_cast( const U & src ) {
+static inline T strict_dynamic_cast( const U & src ) {
 	T ret = dynamic_cast<T>(src);
 	assert(ret);