Index: src/AST/Convert.cpp
===================================================================
--- src/AST/Convert.cpp	(revision 2a54479cc754e390c11af4b63bed63a65cd98e28)
+++ src/AST/Convert.cpp	(revision 546e712c18fe907ee1619132a875d9ba32994efc)
@@ -148,15 +148,27 @@
 
 	const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-		if ( inCache( node ) ) return nullptr;
+		auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
+		auto&& type = get<Type>().accept1( node->type );
+		auto&& init = get<Initializer>().accept1( node->init );
+		auto&& attr = get<Attribute>().acceptL( node->attributes );
+		if ( inCache( node ) ) {
+			if(node->name == "tmp") {
+				std::cerr << (void*)node << "(new) in cache " << (void*)this->node << "(old)" << std::endl;
+			}
+			return nullptr;
+		}
 		auto decl = new ObjectDecl(
 			node->name,
 			Type::StorageClasses( node->storage.val ),
 			LinkageSpec::Spec( node->linkage.val ),
-			get<Expression>().accept1( node->bitfieldWidth ),
-			get<Type>().accept1( node->type ),
-			get<Initializer>().accept1( node->init ),
-			get<Attribute>().acceptL( node->attributes ),
+			bfwd,
+			type,
+			init,
+			attr,
 			Type::FuncSpecifiers( node->funcSpec.val )
 		);
+		if(node->name == "tmp") {
+			std::cerr << (void*)node << "(new) created " << (void*)decl << "(old)" << std::endl;
+		}
 		return declWithTypePostamble( decl, node );
 	}
@@ -719,9 +731,10 @@
 
 	const ast::Expr * visit( const ast::VariableExpr * node ) override final {
-		auto expr = visitBaseExpr( node,
-			new VariableExpr(
-				get<DeclarationWithType>().accept1(node->var)
-			)
-		);
+		auto expr = new VariableExpr();
+		visitBaseExpr( node, expr );
+		expr->var = get<DeclarationWithType>().accept1(node->var);
+		Type * type = expr->var->get_type()->clone();
+		type->set_lvalue( true );
+		expr->set_result( type );
 		this->node = expr;
 		return nullptr;
@@ -1356,11 +1369,21 @@
 		return strict_dynamic_cast< ast::Decl * >( node );
 	}
+
+	ConverterOldToNew() = default;
+	ConverterOldToNew(const ConverterOldToNew &) = delete;
+	ConverterOldToNew(ConverterOldToNew &&) = delete;
 private:
 	/// conversion output
-	ast::Node * node;
+	ast::Node * node = nullptr;
 	/// cache of nodes that might be referenced by readonly<> for de-duplication
-	std::unordered_map< BaseSyntaxNode *, ast::Node * > cache;
+	std::unordered_map< BaseSyntaxNode *, ast::Node * > cache = {};
 
 	// Local Utilities:
+
+	#define construct(T, key, ...) ({ \
+		void * data = ::operator new(sizeof(T)); \
+		cache.emplace( key, (T*)data ); \
+		new (data) T( __VA_ARGS__ ); \
+	})
 
 	template<typename NewT, typename OldT>
@@ -1424,17 +1447,36 @@
 
 	virtual void visit( ObjectDecl * old ) override final {
-		if ( inCache( old ) ) return;
+		if( old->name == "tmp" ) {
+			std::cerr << "building parameters for" << (void*)old << std::endl;
+		}
+		auto&& type = GET_ACCEPT_1(type, Type);
+		auto&& init = GET_ACCEPT_1(init, Init);
+		auto&& bfwd = GET_ACCEPT_1(bitfieldWidth, Expr);
+		auto&& attr = GET_ACCEPT_V(attributes, Attribute);
+		if( old->name == "tmp" ) {
+			std::cerr << "checking cache for " << (void*)old << std::endl;
+		}
+		if ( inCache( old ) ) {
+			if( old->name == "tmp" ) {
+				std::cerr << (void*)old << "(old) in cache " << (void*)this->node << "(new)" << std::endl;
+			}
+			return;
+		}
 		auto decl = new ast::ObjectDecl(
 			old->location,
 			old->name,
-			GET_ACCEPT_1(type, Type),
-			GET_ACCEPT_1(init, Init),
+			type,
+			init,
 			{ old->get_storageClasses().val },
 			{ old->linkage.val },
-			GET_ACCEPT_1(bitfieldWidth, Expr),
-			GET_ACCEPT_V(attributes, Attribute),
+			bfwd,
+			std::move(attr),
 			{ old->get_funcSpec().val }
 		);
-		cache.emplace( old, decl );
+		cache.emplace(old, decl);
+		if( old->name == "tmp" ) {
+			std::cerr << (void*)old << "(old) added to cache with " << (void*)decl << "(new)" << std::endl;
+		}
+		assert(cache.find( old ) != cache.end());
 		decl->scopeLevel = old->scopeLevel;
 		decl->mangleName = old->mangleName;
@@ -1444,4 +1486,8 @@
 
 		this->node = decl;
+
+		if( old->name == "tmp" ) {
+			std::cerr << (void*)old << "(old) created " << (void*)this->node << "(new)" << std::endl;
+		}
 	}
 
@@ -2099,10 +2145,16 @@
 
 	virtual void visit( VariableExpr * old ) override final {
-		this->node = visitBaseExpr( old,
-			new ast::VariableExpr(
-				old->location,
-				GET_ACCEPT_1(var, DeclWithType)
-			)
-		);
+		auto expr = new ast::VariableExpr(
+			old->location
+		);
+
+		visitBaseExpr( old,
+			expr
+		);
+
+		expr->var = GET_ACCEPT_1(var, DeclWithType);
+		expr->result = expr->var->get_type();
+		add_qualifiers( expr->result, ast::CV::Lvalue );
+		this->node = expr;
 	}
 
Index: src/AST/Expr.cpp
===================================================================
--- src/AST/Expr.cpp	(revision 2a54479cc754e390c11af4b63bed63a65cd98e28)
+++ src/AST/Expr.cpp	(revision 546e712c18fe907ee1619132a875d9ba32994efc)
@@ -170,4 +170,7 @@
 // --- VariableExpr
 
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
 VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
 : Expr( loc ), var( v ) {
Index: src/AST/Expr.hpp
===================================================================
--- src/AST/Expr.hpp	(revision 2a54479cc754e390c11af4b63bed63a65cd98e28)
+++ src/AST/Expr.hpp	(revision 546e712c18fe907ee1619132a875d9ba32994efc)
@@ -315,4 +315,5 @@
 	readonly<DeclWithType> var;
 
+	VariableExpr( const CodeLocation & loc );
 	VariableExpr( const CodeLocation & loc, const DeclWithType * v );
 
Index: src/AST/Node.hpp
===================================================================
--- src/AST/Node.hpp	(revision 2a54479cc754e390c11af4b63bed63a65cd98e28)
+++ src/AST/Node.hpp	(revision 546e712c18fe907ee1619132a875d9ba32994efc)
@@ -191,5 +191,5 @@
 	/// wrapper for convenient access to strict_dynamic_cast
 	template<typename o_node_t>
-	const o_node_t * strict_as() const { return strict_dynamic_cast<const o_node_t *>(node); }
+	const o_node_t * strict_as() const { _check(); return strict_dynamic_cast<const o_node_t *>(node); }
 
 	/// Returns a mutable version of the pointer in this node.