Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/GenPoly/Box.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -600,5 +600,5 @@
 
 			// add size/align for generic types to parameter list
-			if ( ! appExpr->get_function()->has_result() ) return;
+			if ( ! appExpr->get_function()->result ) return;
 			FunctionType *funcType = getFunctionType( appExpr->get_function()->get_result() );
 			assert( funcType );
@@ -714,5 +714,5 @@
 
 		void Pass1::boxParam( Type *param, Expression *&arg, const TyVarMap &exprTyVars ) {
-			assertf( arg->has_result(), "arg does not have result: %s", toString( arg ).c_str() );
+			assertf( arg->result, "arg does not have result: %s", toString( arg ).c_str() );
 			if ( isPolyType( param, exprTyVars ) ) {
 				Type * newType = arg->get_result()->clone();
@@ -965,5 +965,5 @@
 				if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
 					if ( varExpr->get_var()->get_name() == "?[?]" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( appExpr->get_args().size() == 2 );
 						Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
@@ -999,5 +999,5 @@
 						} // if
 					} else if ( varExpr->get_var()->get_name() == "*?" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( ! appExpr->get_args().empty() );
 						if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
@@ -1016,5 +1016,5 @@
 						} // if
 					} else if ( varExpr->get_var()->get_name() == "?++" || varExpr->get_var()->get_name() == "?--" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( appExpr->get_args().size() == 1 );
 						if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
@@ -1036,5 +1036,5 @@
 						} // if
 					} else if ( varExpr->get_var()->get_name() == "++?" || varExpr->get_var()->get_name() == "--?" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( appExpr->get_args().size() == 1 );
 						if ( Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env ) ) {
@@ -1042,5 +1042,5 @@
 						} // if
 					} else if ( varExpr->get_var()->get_name() == "?+?" || varExpr->get_var()->get_name() == "?-?" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( appExpr->get_args().size() == 2 );
 						Type *baseType1 = isPolyPtr( appExpr->get_args().front()->get_result(), scopeTyVars, env );
@@ -1068,5 +1068,5 @@
 						} // if
 					} else if ( varExpr->get_var()->get_name() == "?+=?" || varExpr->get_var()->get_name() == "?-=?" ) {
-						assert( appExpr->has_result() );
+						assert( appExpr->result );
 						assert( appExpr->get_args().size() == 2 );
 						Type *baseType = isPolyPtr( appExpr->get_result(), scopeTyVars, env );
@@ -1162,13 +1162,13 @@
 		void Pass1::premutate( AddressExpr * ) { visit_children = false; }
 		Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
-			assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
+			assert( addrExpr->get_arg()->result && ! addrExpr->get_arg()->get_result()->isVoid() );
 
 			bool needs = false;
 			if ( UntypedExpr *expr = dynamic_cast< UntypedExpr *>( addrExpr->get_arg() ) ) {
-				if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+				if ( expr->result && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
 					if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
 						if ( name->get_name() == "*?" ) {
 							if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
-								assert( appExpr->get_function()->has_result() );
+								assert( appExpr->get_function()->result );
 								FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
 								assert( function );
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/GenPoly/Specialize.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -147,5 +147,5 @@
 
 	Expression * Specialize::doSpecialization( Type *formalType, Expression *actual, InferredParams *inferParams ) {
-		assertf( actual->has_result(), "attempting to specialize an untyped expression" );
+		assertf( actual->result, "attempting to specialize an untyped expression" );
 		if ( needsSpecialization( formalType, actual->get_result(), env ) ) {
 			if ( FunctionType *funType = getFunctionType( formalType ) ) {
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/InitTweak/FixInit.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -390,5 +390,5 @@
 			assert( env );
 			CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
-			assert( arg->has_result() );
+			assert( arg->result );
 			Type * result = arg->get_result();
 			if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
@@ -1125,5 +1125,5 @@
 			static UniqueName tempNamer( "_tmp_ctor_expr" );
 			// xxx - is the size check necessary?
-			assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+			assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
 			// xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -839,5 +839,5 @@
 	bool isLvalue( Expression *expr ) {
 		// xxx - recurse into tuples?
-		return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+		return expr->result && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
 	}
 
Index: src/ResolvExpr/ResolveTypeof.cc
===================================================================
--- src/ResolvExpr/ResolveTypeof.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -63,5 +63,5 @@
 		if ( typeofType->get_expr() ) {
 			Expression *newExpr = resolveInVoidContext( typeofType->get_expr(), indexer );
-			assert( newExpr->has_result() && ! newExpr->get_result()->isVoid() );
+			assert( newExpr->result && ! newExpr->get_result()->isVoid() );
 			Type *newType = newExpr->get_result();
 			newExpr->set_result( nullptr );
Index: src/SynTree/AddressExpr.cc
===================================================================
--- src/SynTree/AddressExpr.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/SynTree/AddressExpr.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -33,5 +33,5 @@
 	Type * addrType( Type * type ) {
 		if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
-			return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+			return new ReferenceType( refType->get_qualifiers(), addrType( refType->base ) );
 		} else {
 			return new PointerType( Type::Qualifiers(), type->clone() );
@@ -41,12 +41,12 @@
 
 AddressExpr::AddressExpr( Expression *arg ) : Expression(), arg( arg ) {
-	if ( arg->has_result() ) {
-		if ( arg->get_result()->get_lvalue() ) {
+	if ( arg->result ) {
+		if ( arg->result->get_lvalue() ) {
 			// lvalue, retains all layers of reference and gains a pointer inside the references
-			set_result( addrType( arg->get_result() ) );
+			set_result( addrType( arg->result ) );
 		} else {
 			// taking address of non-lvalue -- must be a reference, loses one layer of reference
-			ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->get_result() );
-			set_result( addrType( refType->get_base() ) );
+			ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( arg->result );
+			set_result( addrType( refType->base ) );
 		}
 		// result of & is never an lvalue
Index: src/SynTree/ApplicationExpr.cc
===================================================================
--- src/SynTree/ApplicationExpr.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/SynTree/ApplicationExpr.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -55,5 +55,5 @@
 	set_result( ResolvExpr::extractResultType( function ) );
 
-	assert( has_result() );
+	assert( result );
 }
 
Index: src/SynTree/Expression.h
===================================================================
--- src/SynTree/Expression.h	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/SynTree/Expression.h	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -45,5 +45,4 @@
 	const Type * get_result() const { return result; }
 	void set_result( Type * newValue ) { result = newValue; }
-	bool has_result() const { return result != nullptr; }
 
 	TypeSubstitution * get_env() const { return env; }
Index: src/Tuples/TupleAssignment.cc
===================================================================
--- src/Tuples/TupleAssignment.cc	(revision bf4b4cfa078d7192399e205b24be58f205c888b6)
+++ src/Tuples/TupleAssignment.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
@@ -84,5 +84,5 @@
 	bool isTuple( Expression *expr ) {
 		if ( ! expr ) return false;
-		assert( expr->has_result() );
+		assert( expr->result );
 		return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
 	}
@@ -238,5 +238,5 @@
 
 	ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
-		assert( expr->has_result() && ! expr->get_result()->isVoid() );
+		assert( expr->result && ! expr->get_result()->isVoid() );
 		ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
 		// if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.