Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision 5f61546f9c00a4a016738bf86554562bd63e7f16)
+++ src/GenPoly/Lvalue.cc	(revision b1ccdfd6bc35f49ab6963b6540bd8e5bbab5efed)
@@ -114,5 +114,5 @@
 	}
 
-	void convertLvalue( std::list< Declaration* >& translationUnit ) {
+	void convertLvalue( std::list< Declaration* > & translationUnit ) {
 		PassVisitor<ReferenceConversions> refCvt;
 		PassVisitor<ReferenceTypeElimination> elim;
@@ -150,6 +150,6 @@
 					// use type of return variable rather than expr result type, since it may have been changed to a pointer type
 					FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
-					Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
-					return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+					Type * ret = ftype->returnVals.empty() ? nullptr : ftype->returnVals.front()->get_type();
+					return func->linkage == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
 				}
 			}
@@ -160,13 +160,12 @@
 			if ( isIntrinsicReference( appExpr ) ) {
 				// eliminate reference types from intrinsic applications - now they return lvalues
-				Type * result = appExpr->get_result();
-				appExpr->set_result( result->stripReferences()->clone() );
-				appExpr->get_result()->set_lvalue( true );
+				Type * result = appExpr->result;
+				appExpr->result = result->stripReferences()->clone();
+				appExpr->result->set_lvalue( true );
 				if ( ! inIntrinsic ) {
 					// when not in an intrinsic function, add a cast to
 					// don't add cast when in an intrinsic function, since they already have the cast
 					Expression * ret = new CastExpr( appExpr, result );
-					ret->set_env( appExpr->get_env() );
-					appExpr->set_env( nullptr );
+					std::swap( ret->env, appExpr->env );
 					return ret;
 				}
@@ -187,10 +186,10 @@
 				assertf( ftype, "Function declaration does not have function type." );
 				// can be of differing lengths only when function is variadic
-				assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
+				assertf( ftype->parameters.size() == appExpr->args.size() || ftype->isVarArgs, "ApplicationExpr args do not match formal parameter type." );
 
 
 				unsigned int i = 0;
-				const unsigned int end = ftype->get_parameters().size();
-				for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
+				const unsigned int end = ftype->parameters.size();
+				for ( auto p : unsafe_group_iterate( appExpr->args, ftype->parameters ) ) {
 					if (i == end) break;
 					Expression *& arg = std::get<0>( p );
@@ -212,8 +211,8 @@
 							// std::cerr << "===adding deref to arg" << std::endl;
 							// if the parameter is a reference, add a dereference to the reference-typed argument.
-							Type * baseType = InitTweak::getPointerBase( arg->get_result() );
-							assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
+							Type * baseType = InitTweak::getPointerBase( arg->result );
+							assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->result ).c_str() );
 							PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
-							delete arg->get_result();
+							delete arg->result;
 							arg->set_result( ptrType );
 							arg = mkDeref( arg );
@@ -249,7 +248,7 @@
 		Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
 			if ( refDepth == 0 ) {
-				if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
+				if ( ! isIntrinsicReference( addrExpr->arg ) ) {
 					// try to avoid ?[?]
-					refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
+					refDepth = addrExpr->arg->result->referenceDepth();
 				}
 			}
@@ -281,12 +280,12 @@
 
 			// conversion to reference type
-			if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
+			if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->result ) ) {
 				(void)refType;
-				if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+				if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
 					// nothing to do if casting from reference to reference.
 					(void)otherRef;
 					PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
-					if ( isIntrinsicReference( castExpr->get_arg() ) ) {
-						Expression * callExpr = castExpr->get_arg();
+					if ( isIntrinsicReference( castExpr->arg ) ) {
+						Expression * callExpr = castExpr->arg;
 						PRINT(
 							std::cerr << "but arg is deref -- &" << std::endl;
@@ -294,10 +293,10 @@
 						)
 						callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
-						delete callExpr->get_result();
+						delete callExpr->result;
 						callExpr->set_result( refType->clone() );
 						// move environment out to new top-level
-						callExpr->set_env( castExpr->get_env() );
-						castExpr->set_arg( nullptr );
-						castExpr->set_env( nullptr );
+						callExpr->env = castExpr->env;
+						castExpr->arg = nullptr;
+						castExpr->env = nullptr;
 						delete castExpr;
 						return callExpr;
@@ -404,7 +403,7 @@
 
 		Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
-			Type * base = refType->get_base();
+			Type * base = refType->base;
 			Type::Qualifiers qualifiers = refType->get_qualifiers();
-			refType->set_base( nullptr );
+			refType->base = nullptr;
 			delete refType;
 			return new PointerType( qualifiers, base );
@@ -414,18 +413,18 @@
 		Expression * GeneralizedLvalue::applyTransformation( Expression * expr, Expression * arg, Func mkExpr ) {
 			if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( arg ) ) {
-				Expression * arg1 = commaExpr->get_arg1()->clone();
-				Expression * arg2 = commaExpr->get_arg2()->clone();
+				Expression * arg1 = commaExpr->arg1->clone();
+				Expression * arg2 = commaExpr->arg2->clone();
 				Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
-				ret->set_env( expr->get_env() );
-				expr->set_env( nullptr );
+				ret->env = expr->env;
+				expr->env = nullptr;
 				delete expr;
 				return ret;
 			} else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
-				Expression * arg1 = condExpr->get_arg1()->clone();
-				Expression * arg2 = condExpr->get_arg2()->clone();
-				Expression * arg3 = condExpr->get_arg3()->clone();
+				Expression * arg1 = condExpr->arg1->clone();
+				Expression * arg2 = condExpr->arg2->clone();
+				Expression * arg3 = condExpr->arg3->clone();
 				ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
-				ret->set_env( expr->get_env() );
-				expr->set_env( nullptr );
+				ret->env = expr->env;
+				expr->env = nullptr;
 				delete expr;
 
@@ -436,6 +435,6 @@
 				AssertionSet needAssertions, haveAssertions;
 				OpenVarSet openVars;
-				unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
-				ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
+				unify( ret->arg2->result, ret->arg3->result, newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
+				ret->result = commonType ? commonType : ret->arg2->result->clone();
 				return ret;
 			}
@@ -444,13 +443,13 @@
 
 		Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
-			return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+			return applyTransformation( memExpr, memExpr->aggregate, [=]( Expression * aggr ) { return new MemberExpr( memExpr->member, aggr ); } );
 		}
 
 		Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
-			return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
+			return applyTransformation( addrExpr, addrExpr->arg, []( Expression * arg ) { return new AddressExpr( arg ); } );
 		}
 
 		Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
-			Expression * arg = addrExpr->get_arg();
+			Expression * arg = addrExpr->arg;
 			if ( isIntrinsicReference( arg ) ) {
 				std::string fname = InitTweak::getFunctionName( arg );
@@ -458,7 +457,7 @@
 					Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
 					Expression * ret = arg0;
-					ret->set_env( addrExpr->get_env() );
+					ret->set_env( addrExpr->env );
 					arg0 = nullptr;
-					addrExpr->set_env( nullptr );
+					addrExpr->env = nullptr;
 					delete addrExpr;
 					return ret;
@@ -487,8 +486,8 @@
 					// }
 					if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
-						Expression * ret = addrExpr->get_arg();
-						ret->set_env( appExpr->get_env() );
-						addrExpr->set_arg( nullptr );
-						appExpr->set_env( nullptr );
+						Expression * ret = addrExpr->arg;
+						ret->env = appExpr->env;
+						addrExpr->arg = nullptr;
+						appExpr->env = nullptr;
 						delete appExpr;
 						return ret;