Index: src/AST/Print.cpp
===================================================================
--- src/AST/Print.cpp	(revision af1e8f56b08eebb76f81dc0a9fb07b0239b067fa)
+++ src/AST/Print.cpp	(revision a16e246a825b05d29de91873c84e14d5e15adb57)
@@ -231,5 +231,5 @@
 			--indent;
 		}
-		
+
 		if ( node->extension ) {
 			os << std::endl << indent << "... with extension";
@@ -659,100 +659,297 @@
 
 	virtual const ast::Expr * visit( const ast::SizeofExpr * node ) {
+		os << "Sizeof Expression on: ";
+		++indent;
+		if ( node->type ) node->type->accept( *this );
+		else safe_print( node->expr );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::AlignofExpr * node ) {
+		os << "Alignof Expression on: ";
+		++indent;
+		if ( node->type ) node->type->accept( *this );
+		else safe_print( node->expr );
+		--indent;
+		postprint( node );
+		
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::UntypedOffsetofExpr * node ) {
+		os << "Untyped Offsetof Expression on member " << node->member << " of ";
+		++indent;
+		safe_print( node->type );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::OffsetofExpr * node ) {
+		os << "Offsetof Expression on member " << node->member->name << " of ";
+		++indent;
+		safe_print( node->type );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::OffsetPackExpr * node ) {
+		os << "Offset Pack Expression on: ";
+		++indent;
+		safe_print( node->type );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::LogicalExpr * node ) {
+		os << "Short-circuited operation (" << (node->isAnd ? "and" : "or") << ") on: ";
+		safe_print( node->arg1 );
+		os << " and ";
+		safe_print( node->arg2 );
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::ConditionalExpr * node ) {
+		++indent;
+		os << "Conditional expression on:" << std::endl << indent;
+		safe_print( node->arg1 );
+		os << indent-1 << "First alternative:" << std::endl << indent;
+		safe_print( node->arg2 );
+		os << indent-1 << "Second alternative:" << std::endl << indent;
+		safe_print( node->arg3 );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::CommaExpr * node ) {
+		++indent;
+		os << "Comma Expression:" << std::endl << indent;
+		safe_print( node->arg1 );
+		os << std::endl << indent;
+		safe_print( node->arg2 );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::TypeExpr * node ) {
+		safe_print( node->type );
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::AsmExpr * node ) {
+		os << "Asm Expression:" << std::endl;
+		++indent;
+		if ( node->inout ) node->inout->accept( *this );
+		if ( node->constraint ) node->constraint->accept( *this );
+		if ( node->operand ) node->operand->accept( *this );
+		--indent;
+		
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::ImplicitCopyCtorExpr * node ) {
+		++indent;
+		os << "Implicit Copy Constructor Expression:" << std::endl << indent;
+		safe_print( node->callExpr );
+		os << std::endl << indent-1 << "... with temporaries:" << std::endl;
+		printAll( node->tempDecls );
+		os << std::endl << indent-1 << "... with return temporaries:" << std::endl;
+		printAll( node->returnDecls );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::ConstructorExpr * node ) {
+		os <<  "Constructor Expression:" << std::endl << indent+1;
+		indent += 2;
+		safe_print( node->callExpr );
+		indent -= 2;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::CompoundLiteralExpr * node ) {
+		++indent;
+		os << "Compound Literal Expression: " << std::endl << indent;
+		safe_print( node->result );
+		os << indent;
+		safe_print( node->init );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::RangeExpr * node ) {
+		os << "Range Expression: ";
+		safe_print( node->low );
+		os << " ... ";
+		safe_print( node->high );
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::UntypedTupleExpr * node ) {
+		os << "Untyped Tuple:" << std::endl;
+		++indent;
+		printAll( node->exprs );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::TupleExpr * node ) {
+		os << "Tuple:" << std::endl;
+		++indent;
+		printAll( node->exprs );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::TupleIndexExpr * node ) {
+		os << "Tuple Index Expression, with tuple:" << std::endl;
+		++indent;
+		os << indent;
+		safe_print( node->tuple );
+		os << indent << "with index: " << node->index << std::endl;
+		--indent;
+		postprint( node );
+		
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::TupleAssignExpr * node ) {
+		os << "Tuple Assignment Expression, with stmt expr:" << std::endl;
+		++indent;
+		os << indent;
+		safe_print( node->stmtExpr );
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::StmtExpr * node ) {
+		++indent;
+		os << "Statement Expression:" << std::endl << indent;
+		safe_print( node->stmts );
+		if ( ! node->returnDecls.empty() ) {
+			os << indent << "... with returnDecls: ";
+			printAll( node->returnDecls );
+		}
+		if ( ! node->dtors.empty() ) {
+			os << indent << "... with dtors: ";
+			printAll( node->dtors );
+		}
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::UniqueExpr * node ) {
+		++indent;
+		os << "Unique Expression with id: " << node->id << std::endl << indent;
+		safe_print( node->expr );
+		if ( node->object ) {
+			os << indent-1 << "... with decl: ";
+			short_print( node->object );
+		}
+		--indent;
+		postprint( node );
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::UntypedInitExpr * node ) {
+		++indent;
+		os << "Untyped Init Expression" << std::endl << indent;
+		safe_print( node->expr );
+		if ( ! node->initAlts.empty() ) {
+			for ( const InitAlternative & alt : node->initAlts ) {
+				os << indent <<  "InitAlternative: ";
+				safe_print( alt.type );
+				safe_print( alt.designation );
+			}
+		}
+		--indent;
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::InitExpr * node ) {
+		++indent;
+		os << "Init Expression" << std::endl << indent;
+		safe_print( node->expr );
+		os << indent << "... with designation: ";
+		safe_print( node->designation );
+		--indent;
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::DeletedExpr * node ) {
+		++indent;
+		os << "Deleted Expression" << std::endl << indent;
+		safe_print( node->expr );
+		os << std::endl << indent << "... deleted by: ";
+		safe_print( node->deleteStmt );
+		--indent;
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::DefaultArgExpr * node ) {
+		++indent;
+		os << "Default Argument Expression" << std::endl << indent;
+		safe_print( node->expr );
+		--indent;
+
 		return node;
 	}
 
 	virtual const ast::Expr * visit( const ast::GenericExpr * node ) {
+		++indent;
+		os << "C11 _Generic Expression" << std::endl << indent;
+		safe_print( node->control );
+		os << std::endl << indent << "... with associations:" << std::endl;
+		for ( const auto & assoc : node->associations ) {
+			os << indent;
+			if ( assoc.type ) {
+				os << "... type: ";
+				assoc.type->accept( *this );
+				os << std::endl << indent << "... expression: ";
+				safe_print( assoc.expr );
+			} else {
+				os << "... default: ";
+				safe_print( assoc.expr );
+			}
+			os << std::endl;
+		}
+		--indent;
+
 		return node;
 	}