Index: src/SynTree/Expression.cc
===================================================================
--- src/SynTree/Expression.cc	(revision 276a55b2c9291e54685e980e0483fef56ee12b7c)
+++ src/SynTree/Expression.cc	(revision be3416ddba79f884d9277e46720fed68f698c5dd)
@@ -10,6 +10,6 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Jul 25 14:15:47 2017
-// Update Count     : 54
+// Last Modified On : Tue Feb 19 18:10:55 2019
+// Update Count     : 60
 //
 
@@ -33,5 +33,5 @@
 #include "GenPoly/Lvalue.h"
 
-void printInferParams( const InferredParams & inferParams, std::ostream &os, Indenter indent, int level ) {
+void printInferParams( const InferredParams & inferParams, std::ostream & os, Indenter indent, int level ) {
 	if ( ! inferParams.empty() ) {
 		os << indent << "with inferred parameters " << level << ":" << std::endl;
@@ -47,5 +47,5 @@
 Expression::Expression() : result( 0 ), env( 0 ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
+Expression::Expression( const Expression & other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 
 void Expression::spliceInferParams( Expression * other ) {
@@ -62,5 +62,5 @@
 }
 
-void Expression::print( std::ostream &os, Indenter indent ) const {
+void Expression::print( std::ostream & os, Indenter indent ) const {
 	printInferParams( inferParams, os, indent+1, 0 );
 
@@ -79,10 +79,10 @@
 }
 
-ConstantExpr::ConstantExpr( const ConstantExpr &other) : Expression( other ), constant( other.constant ) {
+ConstantExpr::ConstantExpr( const ConstantExpr & other) : Expression( other ), constant( other.constant ) {
 }
 
 ConstantExpr::~ConstantExpr() {}
 
-void ConstantExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstantExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "constant expression " ;
 	constant.print( os );
@@ -124,5 +124,5 @@
 }
 
-VariableExpr::VariableExpr( const VariableExpr &other ) : Expression( other ), var( other.var ) {
+VariableExpr::VariableExpr( const VariableExpr & other ) : Expression( other ), var( other.var ) {
 }
 
@@ -137,5 +137,5 @@
 }
 
-void VariableExpr::print( std::ostream &os, Indenter indent ) const {
+void VariableExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Variable Expression: ";
 	var->printShort(os, indent);
@@ -143,15 +143,15 @@
 }
 
-SizeofExpr::SizeofExpr( Expression *expr_ ) :
+SizeofExpr::SizeofExpr( Expression * expr_ ) :
 		Expression(), expr(expr_), type(0), isType(false) {
 	set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( Type *type_ ) :
+SizeofExpr::SizeofExpr( Type * type_ ) :
 		Expression(), expr(0), type(type_), isType(true) {
 	set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-SizeofExpr::SizeofExpr( const SizeofExpr &other ) :
+SizeofExpr::SizeofExpr( const SizeofExpr & other ) :
 	Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -162,5 +162,5 @@
 }
 
-void SizeofExpr::print( std::ostream &os, Indenter indent) const {
+void SizeofExpr::print( std::ostream & os, Indenter indent) const {
 	os << "Sizeof Expression on: ";
 	if (isType) type->print(os, indent+1);
@@ -169,15 +169,15 @@
 }
 
-AlignofExpr::AlignofExpr( Expression *expr_ ) :
+AlignofExpr::AlignofExpr( Expression * expr_ ) :
 		Expression(), expr(expr_), type(0), isType(false) {
 	set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( Type *type_ ) :
+AlignofExpr::AlignofExpr( Type * type_ ) :
 		Expression(), expr(0), type(type_), isType(true) {
 	set_result( new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) );
 }
 
-AlignofExpr::AlignofExpr( const AlignofExpr &other ) :
+AlignofExpr::AlignofExpr( const AlignofExpr & other ) :
 	Expression( other ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -188,5 +188,5 @@
 }
 
-void AlignofExpr::print( std::ostream &os, Indenter indent) const {
+void AlignofExpr::print( std::ostream & os, Indenter indent) const {
 	os << "Alignof Expression on: ";
 	if (isType) type->print(os, indent+1);
@@ -195,5 +195,5 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( Type *type, const std::string &member ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( Type * type, const std::string & member ) :
 		Expression(), type(type), member(member) {
 	assert( type );
@@ -201,5 +201,5 @@
 }
 
-UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr &other ) :
+UntypedOffsetofExpr::UntypedOffsetofExpr( const UntypedOffsetofExpr & other ) :
 	Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -208,5 +208,5 @@
 }
 
-void UntypedOffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void UntypedOffsetofExpr::print( std::ostream & os, Indenter indent) const {
 	os << "Untyped Offsetof Expression on member " << member << " of ";
 	type->print(os, indent+1);
@@ -214,5 +214,5 @@
 }
 
-OffsetofExpr::OffsetofExpr( Type *type, DeclarationWithType *member ) :
+OffsetofExpr::OffsetofExpr( Type * type, DeclarationWithType * member ) :
 		Expression(), type(type), member(member) {
 	assert( member );
@@ -221,5 +221,5 @@
 }
 
-OffsetofExpr::OffsetofExpr( const OffsetofExpr &other ) :
+OffsetofExpr::OffsetofExpr( const OffsetofExpr & other ) :
 	Expression( other ), type( maybeClone( other.type ) ), member( other.member ) {}
 
@@ -228,5 +228,5 @@
 }
 
-void OffsetofExpr::print( std::ostream &os, Indenter indent) const {
+void OffsetofExpr::print( std::ostream & os, Indenter indent) const {
 	os << "Offsetof Expression on member " << member->name << " of ";
 	type->print(os, indent+1);
@@ -234,14 +234,14 @@
 }
 
-OffsetPackExpr::OffsetPackExpr( StructInstType *type ) : Expression(), type( type ) {
+OffsetPackExpr::OffsetPackExpr( StructInstType * type ) : Expression(), type( type ) {
 	assert( type );
 	set_result( new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0, false, false ) );
 }
 
-OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr &other ) : Expression( other ), type( maybeClone( other.type ) ) {}
+OffsetPackExpr::OffsetPackExpr( const OffsetPackExpr & other ) : Expression( other ), type( maybeClone( other.type ) ) {}
 
 OffsetPackExpr::~OffsetPackExpr() { delete type; }
 
-void OffsetPackExpr::print( std::ostream &os, Indenter indent ) const {
+void OffsetPackExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Offset pack expression on ";
 	type->print(os, indent+1);
@@ -249,13 +249,13 @@
 }
 
-AttrExpr::AttrExpr( Expression *attr, Expression *expr_ ) :
+AttrExpr::AttrExpr( Expression * attr, Expression * expr_ ) :
 		Expression(), attr( attr ), expr(expr_), type(0), isType(false) {
 }
 
-AttrExpr::AttrExpr( Expression *attr, Type *type_ ) :
+AttrExpr::AttrExpr( Expression * attr, Type * type_ ) :
 		Expression(), attr( attr ), expr(0), type(type_), isType(true) {
 }
 
-AttrExpr::AttrExpr( const AttrExpr &other ) :
+AttrExpr::AttrExpr( const AttrExpr & other ) :
 		Expression( other ), attr( maybeClone( other.attr ) ), expr( maybeClone( other.expr ) ), type( maybeClone( other.type ) ), isType( other.isType ) {
 }
@@ -267,5 +267,5 @@
 }
 
-void AttrExpr::print( std::ostream &os, Indenter indent) const {
+void AttrExpr::print( std::ostream & os, Indenter indent) const {
 	os << "Attr ";
 	attr->print( os, indent+1);
@@ -278,13 +278,13 @@
 }
 
-CastExpr::CastExpr( Expression *arg, Type *toType, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, Type * toType, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
 	set_result(toType);
 }
 
-CastExpr::CastExpr( Expression *arg, bool isGenerated ) : Expression(), arg(arg), isGenerated( isGenerated ) {
+CastExpr::CastExpr( Expression * arg, bool isGenerated ) : arg(arg), isGenerated( isGenerated ) {
 	set_result( new VoidType( Type::Qualifiers() ) );
 }
 
-CastExpr::CastExpr( const CastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
+CastExpr::CastExpr( const CastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), isGenerated( other.isGenerated ) {
 }
 
@@ -293,6 +293,6 @@
 }
 
-void CastExpr::print( std::ostream &os, Indenter indent ) const {
-	os << "Cast of:" << std::endl << indent+1;
+void CastExpr::print( std::ostream & os, Indenter indent ) const {
+	os << (isGenerated ? "Generated " : "Explicit ") << "Cast of:" << std::endl << indent+1;
 	arg->print(os, indent+1);
 	os << std::endl << indent << "... to:";
@@ -306,8 +306,8 @@
 }
 
-KeywordCastExpr::KeywordCastExpr( Expression *arg, Target target ) : Expression(), arg(arg), target( target ) {
-}
-
-KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+KeywordCastExpr::KeywordCastExpr( Expression * arg, Target target ) : Expression(), arg(arg), target( target ) {
+}
+
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
 }
 
@@ -327,5 +327,5 @@
 }
 
-void KeywordCastExpr::print( std::ostream &os, Indenter indent ) const {
+void KeywordCastExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Keyword Cast of:" << std::endl << indent+1;
 	arg->print(os, indent+1);
@@ -335,9 +335,9 @@
 }
 
-VirtualCastExpr::VirtualCastExpr( Expression *arg_, Type *toType ) : Expression(), arg(arg_) {
+VirtualCastExpr::VirtualCastExpr( Expression * arg_, Type * toType ) : Expression(), arg(arg_) {
 	set_result(toType);
 }
 
-VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr &other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
+VirtualCastExpr::VirtualCastExpr( const VirtualCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ) {
 }
 
@@ -346,5 +346,5 @@
 }
 
-void VirtualCastExpr::print( std::ostream &os, Indenter indent ) const {
+void VirtualCastExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Virtual Cast of:" << std::endl << indent+1;
 	arg->print(os, indent+1);
@@ -359,10 +359,10 @@
 }
 
-UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression *aggregate ) :
+UntypedMemberExpr::UntypedMemberExpr( Expression * member, Expression * aggregate ) :
 		Expression(), member(member), aggregate(aggregate) {
 	assert( aggregate );
 }
 
-UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr &other ) :
+UntypedMemberExpr::UntypedMemberExpr( const UntypedMemberExpr & other ) :
 		Expression( other ), member( maybeClone( other.member ) ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -373,5 +373,5 @@
 }
 
-void UntypedMemberExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedMemberExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Untyped Member Expression, with field: " << std::endl << indent+1;
 	member->print(os, indent+1 );
@@ -381,5 +381,5 @@
 }
 
-MemberExpr::MemberExpr( DeclarationWithType *member, Expression *aggregate ) :
+MemberExpr::MemberExpr( DeclarationWithType * member, Expression * aggregate ) :
 		Expression(), member(member), aggregate(aggregate) {
 	assert( member );
@@ -395,5 +395,5 @@
 }
 
-MemberExpr::MemberExpr( const MemberExpr &other ) :
+MemberExpr::MemberExpr( const MemberExpr & other ) :
 		Expression( other ), member( other.member ), aggregate( maybeClone( other.aggregate ) ) {
 }
@@ -404,5 +404,5 @@
 }
 
-void MemberExpr::print( std::ostream &os, Indenter indent ) const {
+void MemberExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Member Expression, with field:" << std::endl;
 	os << indent+1;
@@ -413,8 +413,8 @@
 }
 
-UntypedExpr::UntypedExpr( Expression *function, const std::list<Expression *> &args ) :
+UntypedExpr::UntypedExpr( Expression * function, const std::list<Expression *> & args ) :
 		Expression(), function(function), args(args) {}
 
-UntypedExpr::UntypedExpr( const UntypedExpr &other ) :
+UntypedExpr::UntypedExpr( const UntypedExpr & other ) :
 		Expression( other ), function( maybeClone( other.function ) ) {
 	cloneAll( other.args, args );
@@ -455,5 +455,5 @@
 
 
-void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
+void UntypedExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Applying untyped:" << std::endl;
 	os << indent+1;
@@ -469,20 +469,20 @@
 }
 
-NameExpr::NameExpr( const NameExpr &other ) : Expression( other ), name( other.name ) {
+NameExpr::NameExpr( const NameExpr & other ) : Expression( other ), name( other.name ) {
 }
 
 NameExpr::~NameExpr() {}
 
-void NameExpr::print( std::ostream &os, Indenter indent ) const {
+void NameExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Name: " << get_name();
 	Expression::print( os, indent );
 }
 
-LogicalExpr::LogicalExpr( Expression *arg1_, Expression *arg2_, bool andp ) :
+LogicalExpr::LogicalExpr( Expression * arg1_, Expression * arg2_, bool andp ) :
 		Expression(), arg1(arg1_), arg2(arg2_), isAnd(andp) {
 	set_result( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
 }
 
-LogicalExpr::LogicalExpr( const LogicalExpr &other ) :
+LogicalExpr::LogicalExpr( const LogicalExpr & other ) :
 		Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), isAnd( other.isAnd ) {
 }
@@ -493,5 +493,5 @@
 }
 
-void LogicalExpr::print( std::ostream &os, Indenter indent )const {
+void LogicalExpr::print( std::ostream & os, Indenter indent )const {
 	os << "Short-circuited operation (" << (isAnd ? "and" : "or") << ") on: ";
 	arg1->print(os);
@@ -504,5 +504,5 @@
 		Expression(), arg1(arg1), arg2(arg2), arg3(arg3) {}
 
-ConditionalExpr::ConditionalExpr( const ConditionalExpr &other ) :
+ConditionalExpr::ConditionalExpr( const ConditionalExpr & other ) :
 		Expression( other ), arg1( maybeClone( other.arg1 ) ), arg2( maybeClone( other.arg2 ) ), arg3( maybeClone( other.arg3 ) ) {
 }
@@ -514,5 +514,5 @@
 }
 
-void ConditionalExpr::print( std::ostream &os, Indenter indent ) const {
+void ConditionalExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Conditional expression on: " << std::endl << indent+1;
 	arg1->print( os, indent+1 );
@@ -527,5 +527,5 @@
 
 
-void AsmExpr::print( std::ostream &os, Indenter indent ) const {
+void AsmExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Asm Expression: " << std::endl;
 	if ( inout ) inout->print( os, indent+1 );
@@ -555,5 +555,5 @@
 }
 
-void ImplicitCopyCtorExpr::print( std::ostream &os, Indenter indent ) const {
+void ImplicitCopyCtorExpr::print( std::ostream & os, Indenter indent ) const {
 	os <<  "Implicit Copy Constructor Expression: " << std::endl << indent+1;
 	callExpr->print( os, indent+1 );
@@ -581,5 +581,5 @@
 }
 
-void ConstructorExpr::print( std::ostream &os, Indenter indent ) const {
+void ConstructorExpr::print( std::ostream & os, Indenter indent ) const {
 	os <<  "Constructor Expression: " << std::endl << indent+1;
 	callExpr->print( os, indent + 2 );
@@ -594,5 +594,5 @@
 }
 
-CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr &other ) : Expression( other ), initializer( other.initializer->clone() ) {}
+CompoundLiteralExpr::CompoundLiteralExpr( const CompoundLiteralExpr & other ) : Expression( other ), initializer( other.initializer->clone() ) {}
 
 CompoundLiteralExpr::~CompoundLiteralExpr() {
@@ -600,5 +600,5 @@
 }
 
-void CompoundLiteralExpr::print( std::ostream &os, Indenter indent ) const {
+void CompoundLiteralExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Compound Literal Expression: " << std::endl << indent+1;
 	result->print( os, indent+1 );
@@ -608,7 +608,7 @@
 }
 
-RangeExpr::RangeExpr( Expression *low, Expression *high ) : low( low ), high( high ) {}
-RangeExpr::RangeExpr( const RangeExpr &other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
-void RangeExpr::print( std::ostream &os, Indenter indent ) const {
+RangeExpr::RangeExpr( Expression * low, Expression * high ) : low( low ), high( high ) {}
+RangeExpr::RangeExpr( const RangeExpr & other ) : Expression( other ), low( other.low->clone() ), high( other.high->clone() ) {}
+void RangeExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Range Expression: ";
 	low->print( os, indent );
@@ -618,8 +618,8 @@
 }
 
-StmtExpr::StmtExpr( CompoundStmt *statements ) : statements( statements ) {
+StmtExpr::StmtExpr( CompoundStmt * statements ) : statements( statements ) {
 	computeResult();
 }
-StmtExpr::StmtExpr( const StmtExpr &other ) : Expression( other ), statements( other.statements->clone() ) {
+StmtExpr::StmtExpr( const StmtExpr & other ) : Expression( other ), statements( other.statements->clone() ) {
 	cloneAll( other.returnDecls, returnDecls );
 	cloneAll( other.dtors, dtors );
@@ -650,5 +650,5 @@
 	}
 }
-void StmtExpr::print( std::ostream &os, Indenter indent ) const {
+void StmtExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Statement Expression: " << std::endl << indent+1;
 	statements->print( os, indent+1 );
@@ -666,5 +666,5 @@
 
 long long UniqueExpr::count = 0;
-UniqueExpr::UniqueExpr( Expression *expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
+UniqueExpr::UniqueExpr( Expression * expr, long long idVal ) : expr( expr ), object( nullptr ), var( nullptr ), id( idVal ) {
 	assert( expr );
 	assert( count != -1 );
@@ -674,5 +674,5 @@
 	}
 }
-UniqueExpr::UniqueExpr( const UniqueExpr &other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
+UniqueExpr::UniqueExpr( const UniqueExpr & other ) : Expression( other ), expr( maybeClone( other.expr ) ), object( maybeClone( other.object ) ), var( maybeClone( other.var ) ), id( other.id ) {
 }
 UniqueExpr::~UniqueExpr() {
@@ -681,5 +681,5 @@
 	delete var;
 }
-void UniqueExpr::print( std::ostream &os, Indenter indent ) const {
+void UniqueExpr::print( std::ostream & os, Indenter indent ) const {
 	os << "Unique Expression with id:" << id << std::endl << indent+1;
 	expr->print( os, indent+1 );
