Index: src/ResolvExpr/AlternativeFinder.cc
===================================================================
--- src/ResolvExpr/AlternativeFinder.cc	(revision e04ef3a33b7695190c509b61da6fe0cfcf46b265)
+++ src/ResolvExpr/AlternativeFinder.cc	(revision 3689906e06b63e9feee3078d0ca524ff10446930)
@@ -39,4 +39,5 @@
 #include "Tuples/NameMatcher.h"
 #include "Common/utility.h"
+#include "InitTweak/InitTweak.h"
 
 extern bool resolvep;
@@ -546,7 +547,6 @@
 
 		{
-			NameExpr *fname = 0;;
-			if ( ( fname = dynamic_cast<NameExpr *>( untypedExpr->get_function()))
-				 && ( fname->get_name() == std::string("&&")) ) {
+			std::string fname = InitTweak::getFunctionName( untypedExpr );
+			if ( fname == "&&" ) {
 				VoidType v = Type::Qualifiers();		// resolve to type void *
 				PointerType pt( Type::Qualifiers(), v.clone() );
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision e04ef3a33b7695190c509b61da6fe0cfcf46b265)
+++ src/ResolvExpr/CommonType.cc	(revision 3689906e06b63e9feee3078d0ca524ff10446930)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// CommonType.cc -- 
+// CommonType.cc --
 //
 // Author           : Richard C. Bilson
@@ -134,4 +134,10 @@
 				result = new BasicType( basicType->get_qualifiers() + otherBasic->get_qualifiers(), newType );
 			} // if
+		} else if ( EnumInstType *enumInstType = dynamic_cast< EnumInstType * > ( type2 ) ) {
+			// use signed int in lieu of the enum type
+			BasicType::Kind newType = combinedType[ basicType->get_kind() ][ BasicType::SignedInt ];
+			if ( ( ( newType == basicType->get_kind() && basicType->get_qualifiers() >= enumInstType->get_qualifiers() ) || widenFirst ) && ( ( newType != basicType->get_kind() && basicType->get_qualifiers() <= enumInstType->get_qualifiers() ) || widenSecond ) ) {
+				result = new BasicType( basicType->get_qualifiers() + enumInstType->get_qualifiers(), newType );
+			} // if
 		} // if
 	}
@@ -183,5 +189,12 @@
 	}
 
-	void CommonType::visit( EnumInstType *aggregateUseType ) {
+	void CommonType::visit( EnumInstType *enumInstType ) {
+		if ( dynamic_cast< BasicType * >( type2 ) ) {
+			// reuse BasicType, EnumInstType code by swapping type2 with enumInstType
+			Type * temp = type2;
+			type2 = enumInstType;
+			temp->accept( *this );
+			type2 = temp;
+		} // if
 	}
 
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision e04ef3a33b7695190c509b61da6fe0cfcf46b265)
+++ src/ResolvExpr/ConversionCost.cc	(revision 3689906e06b63e9feee3078d0ca524ff10446930)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// ConversionCost.cc -- 
+// ConversionCost.cc --
 //
 // Author           : Richard C. Bilson
@@ -157,5 +157,8 @@
 				cost = Cost( 0, 0, tableResult );
 			} // if
-		} // if
+		} else if ( dynamic_cast< EnumInstType *>( dest ) ) {
+			// xxx - not positive this is correct, but appears to allow casting int => enum
+			cost = Cost( 1, 0, 0 );
+    } // if
 	}
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision e04ef3a33b7695190c509b61da6fe0cfcf46b265)
+++ src/ResolvExpr/Resolver.cc	(revision 3689906e06b63e9feee3078d0ca524ff10446930)
@@ -38,4 +38,5 @@
 		virtual void visit( ObjectDecl *functionDecl );
 		virtual void visit( TypeDecl *typeDecl );
+		virtual void visit( EnumDecl * enumDecl );
 
 		virtual void visit( ArrayType * at );
@@ -52,4 +53,5 @@
 		virtual void visit( BranchStmt *branchStmt );
 		virtual void visit( ReturnStmt *returnStmt );
+		virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
 		virtual void visit( SingleInit *singleInit );
@@ -65,4 +67,5 @@
 		Type *initContext;
 		Type *switchType;
+		bool inEnumDecl = false;
 	};
 
@@ -177,5 +180,14 @@
 		Type *temp = initContext;
 		initContext = new_type;
+		if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+			// enumerator initializers should not use the enum type to initialize, since
+			// the enum type is still incomplete at this point. Use signed int instead.
+			initContext = new BasicType( Type::Qualifiers(), BasicType::SignedInt );
+		}
 		SymTab::Indexer::visit( objectDecl );
+		if ( inEnumDecl && dynamic_cast< EnumInstType * >( initContext ) ) {
+			// delete newly created signed int type
+			delete initContext;
+		}
 		initContext = temp;
 	}
@@ -215,4 +227,12 @@
 		SymTab::Indexer::visit( functionDecl );
 		functionReturn = oldFunctionReturn;
+	}
+
+	void Resolver::visit( EnumDecl * enumDecl ) {
+		// in case we decide to allow nested enums
+		bool oldInEnumDecl = inEnumDecl;
+		inEnumDecl = true;
+		SymTab::Indexer::visit( enumDecl );
+		inEnumDecl = oldInEnumDecl;
 	}
 
@@ -492,5 +512,5 @@
 		} catch ( SemanticError ) {
 			// no alternatives for the constructor initializer - fallback on C-style initializer
-			// xxx- not sure if this makes a ton of sense - should maybe never be able to have this situation?
+			// xxx - not sure if this makes a ton of sense - should maybe never be able to have this situation?
 			fallbackInit( ctorInit );
 			return;
@@ -513,4 +533,46 @@
 		}
 	}
+
+	void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
+		// before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed).
+		// Do this through a cast expression to greatly simplify the code.
+		Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
+		assert( callExpr );
+		Expression *& constructee = InitTweak::getCallArg( callExpr, 0 );
+		Type * type = 0;
+
+		// need to find the type of the first argument, which is unfortunately not uniform since array construction
+		// includes an untyped '+' expression.
+		if ( UntypedExpr * plusExpr = dynamic_cast< UntypedExpr * >( constructee ) ) {
+			// constructee is <array>+<index>
+			// get Variable <array>, then get the base type of the VariableExpr - this is the type that needs to be fixed
+			Expression * arr = InitTweak::getCallArg( plusExpr, 0 );
+			assert( dynamic_cast< VariableExpr * >( arr ) );
+			assert( arr && arr->get_results().size() == 1 );
+			type = arr->get_results().front()->clone();
+		} else {
+			// otherwise, constructing a plain object, which means the object's address is being taken.
+			// Need to get the type of the VariableExpr object, because the AddressExpr is rebuilt and uses the
+			// type of the VariableExpr to do so.
+			assert( constructee->get_results().size() == 1 );
+			AddressExpr * addrExpr = dynamic_cast< AddressExpr * > ( constructee );
+			assert( addrExpr && addrExpr->get_results().size() == 1);
+			type = addrExpr->get_results().front()->clone();
+		}
+		// cast to T* with qualifiers removed.
+		// unfortunately, lvalue is considered a qualifier. For AddressExpr to resolve, its argument
+		// must have an lvalue qualified type, so remove all qualifiers except lvalue. If we ever
+		// remove lvalue as a qualifier, this can change to
+		//   type->get_qualifiers() = Type::Qualifiers();
+		Type * base = InitTweak::getPointerBase( type );
+		assert( base );
+		base->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+		// if pointer has lvalue qualifier, cast won't appear in output
+		type->set_isLvalue( false );
+		constructee = new CastExpr( constructee, type );
+
+		// finally, resolve the ctor/dtor
+		impCtorDtorStmt->get_callStmt()->accept( *this );
+	}
 } // namespace ResolvExpr