Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 70f89d00f25700f0fc226d5210840f0199c6d9f0)
+++ src/ResolvExpr/Resolver.cc	(revision f1b1e4c22ee1c825678ab38142bbcf3879708434)
@@ -52,4 +52,5 @@
 		virtual void visit( BranchStmt *branchStmt );
 		virtual void visit( ReturnStmt *returnStmt );
+		virtual void visit( ImplicitCtorDtorStmt * impCtorDtorStmt );
 
 		virtual void visit( SingleInit *singleInit );
@@ -493,12 +494,7 @@
 			// 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?
-
-			// reset type qualifiers
-			ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
 			fallbackInit( ctorInit );
 			return;
 		}
-		// reset type qualifiers
-		ctorInit->get_object()->get_type()->get_qualifiers() = ctorInit->get_qualifiers();
 
 		// found a constructor - can get rid of C-style initializer
@@ -518,4 +514,50 @@
 		}
 	}
+
+	void Resolver::visit( ImplicitCtorDtorStmt * impCtorDtorStmt ) {
+		// this code is fairly gross. If VariableExpr didn't have its own results list then this could be cleaned up a bit
+		// by remembering the ObjectDecl in the ImplicitCtorDtorStmt and changing the ObjectDecl's type temporarily, but currently
+		// VariableExprs have their own type list which is manipulated in AlternativeFinder (e.g. in inferRecursive).
+
+		// before resolving ctor/dtor, need to remove type qualifiers from the first argument (the object being constructed)
+		Expression * callExpr = InitTweak::getCtorDtorCall( impCtorDtorStmt );
+		assert( callExpr );
+		Expression * constructee = InitTweak::getCallArg( callExpr, 0 );
+		Type * type = 0;
+		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 );
+			ArrayType * arrType = dynamic_cast< ArrayType * >( arr->get_results().front() );
+			assert( arrType );
+			type = arrType->get_base();
+		} 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 );
+			VariableExpr * varExpr = dynamic_cast< VariableExpr * >( addrExpr->get_arg() );
+			assert( varExpr && varExpr->get_results().size() == 1 );
+			type = varExpr->get_results().front();
+		}
+		// remember qualifiers so they can be replaced
+		Type::Qualifiers qualifiers = type->get_qualifiers();
+
+		// 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->get_qualifiers() -= Type::Qualifiers(true, true, true, false, true, true);
+
+		// finally, resolve the ctor/dtor
+		impCtorDtorStmt->get_callStmt()->accept( *this );
+
+		// and reset type qualifiers after resolving
+		type->get_qualifiers() = qualifiers;
+	}
 } // namespace ResolvExpr