Index: src/ResolvExpr/CastCost.cc
===================================================================
--- src/ResolvExpr/CastCost.cc	(revision b8a4f47b1e7e8762a51ca29faaf9b54178526589)
+++ src/ResolvExpr/CastCost.cc	(revision eb0aedbaf6314c925dca18aa088dd6056485b500)
@@ -52,6 +52,6 @@
 				// all typedefs should be gone by this point
 				TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
-				if ( type->get_base() ) {
-					return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
+				if ( type->base ) {
+					return castCost( src, type->base, indexer, env ) + Cost::safe;
 				} // if
 			} // if
@@ -105,11 +105,11 @@
 	void CastCost::visit( PointerType *pointerType ) {
 		if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-			if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+			if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
 				cost = Cost::safe;
 			} else {
 				TypeEnvironment newEnv( env );
-				newEnv.add( pointerType->get_forall() );
-				newEnv.add( pointerType->get_base()->get_forall() );
-				int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
+				newEnv.add( pointerType->forall );
+				newEnv.add( pointerType->base->forall );
+				int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
 				if ( castResult > 0 ) {
 					cost = Cost::safe;
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision b8a4f47b1e7e8762a51ca29faaf9b54178526589)
+++ src/ResolvExpr/ConversionCost.cc	(revision eb0aedbaf6314c925dca18aa088dd6056485b500)
@@ -44,6 +44,6 @@
 			EqvClass eqvClass;
 			NamedTypeDecl *namedType;
-			PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
-			if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+			PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
+			if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
 				if ( eqvClass.type ) {
 					return conversionCost( src, eqvClass.type, indexer, env );
@@ -51,11 +51,11 @@
 					return Cost::infinity;
 				}
-			} else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+			} else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
 				PRINT( std::cerr << " found" << std::endl; )
 				TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
 				// all typedefs should be gone by this point
 				assert( type );
-				if ( type->get_base() ) {
-					return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
+				if ( type->base ) {
+					return conversionCost( src, type->base, indexer, env ) + Cost::safe;
 				} // if
 			} // if
@@ -95,10 +95,10 @@
 		if ( diff > 0 ) {
 			// TODO: document this
-			Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+			Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
 			cost.incReference();
 			return cost;
 		} else if ( diff < -1 ) {
 			// TODO: document this
-			Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+			Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
 			cost.incReference();
 			return cost;
@@ -108,7 +108,7 @@
 			if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
 				PRINT( std::cerr << "converting between references" << std::endl; )
-				Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
-				Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
-				if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+				Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
+				Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
+				if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
 					PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
 					if ( tq1 == tq2 ) {
@@ -120,5 +120,5 @@
 					}
 				} else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-					int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
+					int assignResult = func( srcAsRef->base, destAsRef->base, env, indexer );
 					PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
 					if ( assignResult > 0 ) {
@@ -138,5 +138,5 @@
 			assert( diff == -1 && destAsRef );
 			PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
-			if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+			if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
 				PRINT( std::cerr << "converting compatible base type" << std::endl; )
 				if ( src->get_lvalue() ) {
@@ -146,12 +146,12 @@
 					)
 					// lvalue-to-reference conversion:  cv lvalue T => cv T &
-					if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+					if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
 						return Cost::reference; // cost needs to be non-zero to add cast
-					} if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+					} if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
 						return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
 					} else {
 						return Cost::unsafe;
 					} // if
-				} else if ( destAsRef->get_base()->get_const() ) {
+				} else if ( destAsRef->base->get_const() ) {
 					PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
 					// rvalue-to-const-reference conversion: T => const T &
@@ -281,7 +281,7 @@
 		if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
 			PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
-			Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
-			Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
-			if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+			Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
+			Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
+			if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
 				PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
 				if ( tq1 == tq2 ) {
@@ -363,16 +363,16 @@
 		EqvClass eqvClass;
 		NamedTypeDecl *namedType;
-		if ( env.lookup( inst->get_name(), eqvClass ) ) {
+		if ( env.lookup( inst->name, eqvClass ) ) {
 			cost = conversionCost( eqvClass.type, dest, indexer, env );
 		} else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
-			if ( inst->get_name() == destAsInst->get_name() ) {
+			if ( inst->name == destAsInst->name ) {
 				cost = Cost::zero;
 			}
-		} else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
+		} else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
 			TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
 			// all typedefs should be gone by this point
 			assert( type );
-			if ( type->get_base() ) {
-				cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
+			if ( type->base ) {
+				cost = conversionCost( type->base, dest, indexer, env ) + Cost::safe;
 			} // if
 		} // if
@@ -382,7 +382,7 @@
 		Cost c = Cost::zero;
 		if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
-			std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
-			std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
-			while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
+			std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
+			std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
+			while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
 				Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
 				if ( newCost == Cost::infinity ) {
@@ -391,5 +391,5 @@
 				c += newCost;
 			} // while
-			if ( destIt != destAsTuple->get_types().end() ) {
+			if ( destIt != destAsTuple->types.end() ) {
 				cost = Cost::infinity;
 			} else {