Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/CodeGen/CodeGenerator.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -203,4 +203,6 @@
 
 	void CodeGenerator::handleAggregate( AggregateDecl * aggDecl, const std::string & kind ) {
+		genAttributes( aggDecl->get_attributes() );
+
 		if( ! aggDecl->get_parameters().empty() && ! genC ) {
 			// assertf( ! genC, "Aggregate type parameters should not reach code generation." );
@@ -211,7 +213,5 @@
 		}
 
-		output << kind;
-		genAttributes( aggDecl->get_attributes() );
-		output << aggDecl->get_name();
+		output << kind << aggDecl->get_name();
 
 		if ( aggDecl->has_body() ) {
@@ -298,12 +298,4 @@
 			output << " }";
 		}
-	}
-
-	void CodeGenerator::postvisit( StaticAssertDecl * assertDecl ) {
-		output << "_Static_assert(";
-		assertDecl->condition->accept( *visitor );
-		output << ", ";
-		assertDecl->message->accept( *visitor );
-		output << ")";
 	}
 
Index: src/CodeGen/CodeGenerator.h
===================================================================
--- src/CodeGen/CodeGenerator.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/CodeGen/CodeGenerator.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -42,10 +42,9 @@
 		void postvisit( FunctionDecl * );
 		void postvisit( ObjectDecl * );
-		void postvisit( UnionDecl * aggregateDecl );
-		void postvisit( EnumDecl * aggregateDecl );
-		void postvisit( TraitDecl * aggregateDecl );
-		void postvisit( TypedefDecl * typeDecl );
-		void postvisit( TypeDecl * typeDecl );
-		void postvisit( StaticAssertDecl * assertDecl );
+		void postvisit( UnionDecl *aggregateDecl );
+		void postvisit( EnumDecl *aggregateDecl );
+		void postvisit( TraitDecl *aggregateDecl );
+		void postvisit( TypedefDecl *typeDecl );
+		void postvisit( TypeDecl *typeDecl );
 
 		//*** Initializer
Index: src/CodeGen/OperatorTable.cc
===================================================================
--- src/CodeGen/OperatorTable.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/CodeGen/OperatorTable.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -79,5 +79,5 @@
 	} // namespace
 
-	bool operatorLookup( const std::string & funcName, OperatorInfo & info ) {
+	bool operatorLookup( std::string funcName, OperatorInfo &info ) {
 		static bool init = false;
 		if ( ! init ) {
@@ -100,9 +100,4 @@
 			return true;
 		} // if
-	}
-
-	bool isOperator( const std::string & funcName ) {
-		OperatorInfo info;
-		return operatorLookup( funcName, info );
 	}
 
Index: src/CodeGen/OperatorTable.h
===================================================================
--- src/CodeGen/OperatorTable.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/CodeGen/OperatorTable.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -41,6 +41,5 @@
 	};
 
-	bool isOperator( const std::string & funcName );
-	bool operatorLookup( const std::string & funcName, OperatorInfo & info );
+	bool operatorLookup( std::string funcName, OperatorInfo &info );
 
 	bool isConstructor( const std::string & );
Index: src/Common/Debug.h
===================================================================
--- src/Common/Debug.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Common/Debug.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -28,5 +28,5 @@
 namespace Debug {
 	/// debug codegen a translation unit
-	static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
+	static inline void codeGen( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
 	#ifdef DEBUG
 		std::list< Declaration * > decls;
@@ -41,5 +41,5 @@
 	} // dump
 
-	static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, __attribute__((unused)) LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
+	static inline void treeDump( __attribute__((unused)) const std::list< Declaration * > & translationUnit, __attribute__((unused)) const std::string & label, LinkageSpec::Spec linkageFilter = LinkageSpec::Compiler ) {
 	#ifdef DEBUG
 		std::list< Declaration * > decls;
Index: src/Common/ErrorObjects.h
===================================================================
--- src/Common/ErrorObjects.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Common/ErrorObjects.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -35,5 +35,5 @@
 class SemanticErrorException : public std::exception {
   public:
-	SemanticErrorException() = default;
+  	SemanticErrorException() = default;
 	SemanticErrorException( CodeLocation location, std::string error );
 	~SemanticErrorException() throw() {}
Index: src/Common/PassVisitor.h
===================================================================
--- src/Common/PassVisitor.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Common/PassVisitor.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -66,5 +66,4 @@
 	virtual void visit( TypedefDecl * typeDecl ) override final;
 	virtual void visit( AsmDecl * asmDecl ) override final;
-	virtual void visit( StaticAssertDecl * assertDecl ) override final;
 
 	virtual void visit( CompoundStmt * compoundStmt ) override final;
@@ -162,5 +161,4 @@
 	virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
 	virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
-	virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;
 
 	virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) override final;
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Common/PassVisitor.impl.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -685,26 +685,4 @@
 
 //--------------------------------------------------------------------------
-// StaticAssertDecl
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( StaticAssertDecl * node ) {
-	VISIT_START( node );
-
-	maybeAccept_impl( node->condition, *this );
-	maybeAccept_impl( node->message  , *this );
-
-	VISIT_END( node );
-}
-
-template< typename pass_type >
-StaticAssertDecl * PassVisitor< pass_type >::mutate( StaticAssertDecl * node ) {
-	MUTATE_START( node );
-
-	maybeMutate_impl( node->condition, *this );
-	maybeMutate_impl( node->message  , *this );
-
-	MUTATE_END( StaticAssertDecl, node );
-}
-
-//--------------------------------------------------------------------------
 // CompoundStmt
 template< typename pass_type >
@@ -1512,4 +1490,5 @@
 	indexerScopedAccept( node->result, *this );
 	maybeAccept_impl   ( node->type  , *this );
+	maybeAccept_impl   ( node->member, *this );
 
 	VISIT_END( node );
@@ -1523,4 +1502,5 @@
 	indexerScopedMutate( node->result, *this );
 	maybeMutate_impl   ( node->type  , *this );
+	maybeMutate_impl   ( node->member, *this );
 
 	MUTATE_END( Expression, node );
Index: src/GenPoly/Lvalue.cc
===================================================================
--- src/GenPoly/Lvalue.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/GenPoly/Lvalue.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -45,5 +45,4 @@
 		Expression * mkDeref( Expression * arg ) {
 			if ( SymTab::dereferenceOperator ) {
-				// note: reference depth can be arbitrarily deep here, so peel off the outermost pointer/reference, not just pointer because they are effecitvely equivalent in this pass
 				VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
 				deref->result = new PointerType( Type::Qualifiers(), deref->result );
@@ -198,23 +197,18 @@
 					PRINT(
 						std::cerr << "pair<0>: " << arg << std::endl;
-						std::cerr << " -- " << arg->result << std::endl;
 						std::cerr << "pair<1>: " << formal << std::endl;
 					)
 					if ( dynamic_cast<ReferenceType*>( formal ) ) {
-						PRINT(
-							std::cerr << "===formal is reference" << std::endl;
-						)
-						// TODO: it's likely that the second condition should be ... && ! isIntrinsicReference( arg ), but this requires investigation.
-						if ( function->get_linkage() != LinkageSpec::Intrinsic && isIntrinsicReference( arg ) ) {
-							// if argument is dereference or array subscript, the result isn't REALLY a reference, but non-intrinsic functions expect a reference: take address
-							PRINT(
-								std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
-							)
-							arg = new AddressExpr( arg );
-						} else if ( function->get_linkage() == LinkageSpec::Intrinsic && arg->result->referenceDepth() != 0 ) {
-							// argument is a 'real' reference, but function expects a C lvalue: add a dereference to the reference-typed argument
-							PRINT(
-								std::cerr << "===is non-intrinsic arg in intrinsic call - adding deref to arg" << std::endl;
-							)
+						if ( isIntrinsicReference( arg ) ) { // do not combine conditions, because that changes the meaning of the else if
+							if ( function->get_linkage() != LinkageSpec::Intrinsic ) { // intrinsic functions that turn pointers into references
+								// if argument is dereference or array subscript, the result isn't REALLY a reference, so it's not necessary to fix the argument
+								PRINT(
+									std::cerr << "===is intrinsic arg in non-intrinsic call - adding address" << std::endl;
+								)
+								arg = new AddressExpr( arg );
+							}
+						} else if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
+							// std::cerr << "===adding deref to arg" << std::endl;
+							// if the parameter is a reference, add a dereference to the reference-typed argument.
 							Type * baseType = InitTweak::getPointerBase( arg->result );
 							assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->result ).c_str() );
@@ -223,5 +217,4 @@
 							arg->set_result( ptrType );
 							arg = mkDeref( arg );
-							assertf( arg->result->referenceDepth() == 0, "Reference types should have been eliminated from intrinsic function calls, but weren't: %s", toCString( arg->result ) );
 						}
 					}
Index: src/Parser/DeclarationNode.cc
===================================================================
--- src/Parser/DeclarationNode.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Parser/DeclarationNode.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -71,7 +71,4 @@
 	attr.expr = nullptr;
 	attr.type = nullptr;
-
-	assert.condition = nullptr;
-	assert.message = nullptr;
 }
 
@@ -91,7 +88,4 @@
 	// asmName, no delete, passed to next stage
 	delete initializer;
-
-	delete assert.condition;
-	delete assert.message;
 }
 
@@ -123,7 +117,4 @@
 	newnode->attr.expr = maybeClone( attr.expr );
 	newnode->attr.type = maybeClone( attr.type );
-
-	newnode->assert.condition = maybeClone( assert.condition );
-	newnode->assert.message = maybeClone( assert.message );
 	return newnode;
 } // DeclarationNode::clone
@@ -443,12 +434,4 @@
 	return newnode;
 }
-
-DeclarationNode * DeclarationNode::newStaticAssert( ExpressionNode * condition, Expression * message ) {
-	DeclarationNode * newnode = new DeclarationNode;
-	newnode->assert.condition = condition;
-	newnode->assert.message = message;
-	return newnode;
-}
-
 
 void appendError( string & dst, const string & src ) {
@@ -1069,8 +1052,4 @@
 	} // if
 
-	if ( assert.condition ) {
-		return new StaticAssertDecl( maybeBuild< Expression >( assert.condition ), strict_dynamic_cast< ConstantExpr * >( maybeClone( assert.message ) ) );
-	}
-
 	// SUE's cannot have function specifiers, either
 	//
Index: src/Parser/ParseNode.h
===================================================================
--- src/Parser/ParseNode.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Parser/ParseNode.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -246,5 +246,4 @@
 	static DeclarationNode * newAttribute( std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
 	static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
-	static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
 
 	DeclarationNode();
@@ -314,10 +313,4 @@
 	Attr_t attr;
 
-	struct StaticAssert_t {
-		ExpressionNode * condition;
-		Expression * message;
-	};
-	StaticAssert_t assert;
-
 	BuiltinType builtin;
 
Index: src/Parser/parser.yy
===================================================================
--- src/Parser/parser.yy	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/Parser/parser.yy	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -1314,5 +1314,5 @@
 static_assert:
 	STATICASSERT '(' constant_expression ',' string_literal ')' ';' // C11
-		{ $$ = DeclarationNode::newStaticAssert( $3, $5 ); }
+		{ SemanticError( yylloc, "Static assert is currently unimplemented." ); $$ = nullptr; }
 
 // C declaration syntax is notoriously confusing and error prone. Cforall provides its own type, variable and function
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/ResolvExpr/CommonType.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -27,10 +27,5 @@
 #include "typeops.h"                     // for isFtype
 
-#define DEBUG
-#ifdef DEBUG
-#define PRINT(x) x
-#else
-#define PRINT(x)
-#endif
+// #define DEBUG
 
 namespace ResolvExpr {
@@ -75,11 +70,7 @@
 		// need unify to bind type variables
 		if ( unify( t1, t2, env, have, need, newOpen, indexer, common ) ) {
-			PRINT(
-				std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
-			)
+			// std::cerr << "unify success: " << widenFirst << " " << widenSecond << std::endl;
 			if ( (widenFirst || t2->get_qualifiers() <= t1->get_qualifiers()) && (widenSecond || t1->get_qualifiers() <= t2->get_qualifiers()) ) {
-				PRINT(
-					std::cerr << "widen okay" << std::endl;
-				)
+				// std::cerr << "widen okay" << std::endl;
 				common->get_qualifiers() |= t1->get_qualifiers();
 				common->get_qualifiers() |= t2->get_qualifiers();
@@ -87,7 +78,5 @@
 			}
 		}
-		PRINT(
-			std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
-		)
+		// std::cerr << "exact unify failed: " << t1 << " " << t2 << std::endl;
 		return nullptr;
 	}
@@ -105,7 +94,5 @@
 			// special case where one type has a reference depth of 1 larger than the other
 			if ( diff > 0 || diff < 0 ) {
-				PRINT(
-					std::cerr << "reference depth diff: " << diff << std::endl;
-				)
+				// std::cerr << "reference depth diff: " << diff << std::endl;
 				Type * result = nullptr;
 				ReferenceType * ref1 = dynamic_cast< ReferenceType * >( type1 );
@@ -122,12 +109,8 @@
 				if ( result && ref1 ) {
 					// formal is reference, so result should be reference
-					PRINT(
-						std::cerr << "formal is reference; result should be reference" << std::endl;
-					)
+					// std::cerr << "formal is reference; result should be reference" << std::endl;
 					result = new ReferenceType( ref1->get_qualifiers(), result );
 				}
-				PRINT(
-					std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
-				)
+				// std::cerr << "common type of reference [" << type1 << "] and [" << type2 << "] is [" << result << "]" << std::endl;
 				return result;
 			}
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/ResolvExpr/Resolver.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -59,5 +59,4 @@
 		void previsit( TypeDecl *typeDecl );
 		void previsit( EnumDecl * enumDecl );
-		void previsit( StaticAssertDecl * assertDecl );
 
 		void previsit( ArrayType * at );
@@ -362,8 +361,4 @@
 		GuardValue( inEnumDecl );
 		inEnumDecl = true;
-	}
-
-	void Resolver::previsit( StaticAssertDecl * assertDecl ) {
-		findIntegralExpression( assertDecl->condition, indexer );
 	}
 
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SymTab/Validate.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -89,5 +89,4 @@
 		void previsit( StructDecl * aggregateDecl );
 		void previsit( UnionDecl * aggregateDecl );
-		void previsit( StaticAssertDecl * assertDecl );
 
 	  private:
@@ -297,6 +296,6 @@
 	}
 
-	bool shouldHoist( Declaration *decl ) {
-		return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl ) || dynamic_cast< StaticAssertDecl * >( decl );
+	bool isStructOrUnion( Declaration *decl ) {
+		return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl );
 	}
 
@@ -311,5 +310,5 @@
 		} // if
 		// Always remove the hoisted aggregate from the inner structure.
-		GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, shouldHoist, false ); } );
+		GuardAction( [aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
 	}
 
@@ -329,10 +328,4 @@
 		if ( inst->baseUnion ) {
 			declsToAddBefore.push_front( inst->baseUnion );
-		}
-	}
-
-	void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
-		if ( parentAggr ) {
-			declsToAddBefore.push_back( assertDecl );
 		}
 	}
@@ -637,8 +630,4 @@
 			forallFixer( pointer->base->forall, object );
 		} // if
-		// ensure that operator names only apply to functions or function pointers
-		if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
-			SemanticError( object->location, toCString( "operator ", object->name.c_str(), " is not a function or function pointer." )  );
-		}
 		object->fixUniqueId();
 	}
Index: src/SynTree/Declaration.cc
===================================================================
--- src/SynTree/Declaration.cc	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SynTree/Declaration.cc	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -81,27 +81,4 @@
 
 
-StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
-}
-
-StaticAssertDecl::StaticAssertDecl( const StaticAssertDecl & other ) : Declaration( other ), condition( maybeClone( other.condition ) ), message( maybeClone( other.message ) )  {
-}
-
-StaticAssertDecl::~StaticAssertDecl() {
-	delete condition;
-	delete message;
-}
-
-void StaticAssertDecl::print( std::ostream &os, Indenter indent ) const {
-	os << "Static Assert with condition: ";
-	condition->print( os, indent+1 );
-	os << std::endl << indent << "and message: ";
-	message->print( os, indent+1 );
-os << std::endl;
-}
-
-void StaticAssertDecl::printShort( std::ostream &os, Indenter indent ) const {
-	print( os, indent );
-}
-
 // Local Variables: //
 // tab-width: 4 //
Index: src/SynTree/Declaration.h
===================================================================
--- src/SynTree/Declaration.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SynTree/Declaration.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -365,20 +365,4 @@
 };
 
-class StaticAssertDecl : public Declaration {
-public:
-	Expression * condition;
-	ConstantExpr * message;   // string literal
-
-	StaticAssertDecl( Expression * condition, ConstantExpr * message );
-	StaticAssertDecl( const StaticAssertDecl & other );
-	virtual ~StaticAssertDecl();
-
-	virtual StaticAssertDecl * clone() const override { return new StaticAssertDecl( *this ); }
-	virtual void accept( Visitor &v ) override { v.visit( this ); }
-	virtual StaticAssertDecl * acceptMutator( Mutator &m )  override { return m.mutate( this ); }
-	virtual void print( std::ostream &os, Indenter indent = {} ) const override;
-	virtual void printShort( std::ostream &os, Indenter indent = {} ) const override;
-};
-
 std::ostream & operator<<( std::ostream & os, const TypeDecl::Data & data );
 
Index: src/SynTree/Mutator.h
===================================================================
--- src/SynTree/Mutator.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SynTree/Mutator.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -34,5 +34,4 @@
 	virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
 	virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
-	virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;
 
 	virtual CompoundStmt * mutate( CompoundStmt * compoundStmt ) = 0;
Index: src/SynTree/SynTree.h
===================================================================
--- src/SynTree/SynTree.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SynTree/SynTree.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -38,5 +38,4 @@
 class TypedefDecl;
 class AsmDecl;
-class StaticAssertDecl;
 
 class Statement;
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/SynTree/Visitor.h	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -36,5 +36,4 @@
 	virtual void visit( TypedefDecl * typeDecl ) = 0;
 	virtual void visit( AsmDecl * asmDecl ) = 0;
-	virtual void visit( StaticAssertDecl * assertDecl ) = 0;
 
 	virtual void visit( CompoundStmt * compoundStmt ) = 0;
Index: src/tests/.expect/references.txt
===================================================================
--- src/tests/.expect/references.txt	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/tests/.expect/references.txt	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -4,8 +4,4 @@
 13 1 12
 14 14
-x = 6 ; x2 = 789
-x = 6 ; x2 = 999
-x = 12345 ; x2 = 999
-x = 22222 ; x2 = 999
 Default constructing a Y
 Copy constructing a Y
Index: src/tests/operators.c
===================================================================
--- src/tests/operators.c	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/tests/operators.c	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -27,4 +27,6 @@
 	a(b);
 	a + b;
+	struct accumulator ?+?;	// why not, eh?
+	a + b;
 }
 
Index: src/tests/references.c
===================================================================
--- src/tests/references.c	(revision ca374456181d2f3ca0a61f3c111e0b915fa01059)
+++ src/tests/references.c	(revision 8ad653339f39e704e4be3cbd354de857c44a52f4)
@@ -46,9 +46,13 @@
 
 int main() {
-	int x = 123456, x2 = 789, *p1 = &x, **p2 = &p1, ***p3 = &p2,
+	int x = 123456, *p1 = &x, **p2 = &p1, ***p3 = &p2,
 		&r1 = x,    &&r2 = r1,   &&&r3 = r2;
 	***p3 = 3;                          // change x
+	// ((int&)r3 = 3;                      // change x, ***r3
 	**p3 = &x;                          // change p1
+	// ((int*&)&r3) = &x;                  // change r1, (&*)**r3
 	*p3 = &p1;                          // change p2
+	// ((int**&)&&r3) = &p2;               // change r2, (&(&*)*)*r3
+	// ((int***&)&&&r3) = p3;              // change r3 to p3, (&(&(&*)*)*)r3
 	int y = 0, z = 11, & ar[3] = { x, y, z };    // initialize array of references
 	// &ar[1] = &z;                        // change reference array element
@@ -58,6 +62,4 @@
 	// sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference
 
-	((int*&)&r3) = &x;                  // change r1, (&*)**r3
-	x = 3;
 	// test that basic reference properties are true - r1 should be an alias for x
 	printf("%d %d %d\n", x, r1, &x == &r1);
@@ -74,16 +76,4 @@
 	changeRef( r1 );
 	printf("%d %d\n", r1, x);
-
-	((int&)r3) = 6;                       // change x, ***r3
-	printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
-	((int*&)&r3) = &x2;                   // change r1 to refer to x2, (&*)**r3
-	((int&)r3) = 999;                     // modify x2
-	printf("x = %d ; x2 = %d\n", x, x2);  // check that x2 was changed
-	((int**&)&&r3) = p2;                  // change r2, (&(&*)*)*r3
-	((int&)r3) = 12345;                   // modify x
-	printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
-	((int***&)&&&r3) = p3;                // change r3 to p3, (&(&(&*)*)*)r3
-	((int&)r3) = 22222;                   // modify x
-	printf("x = %d ; x2 = %d\n", x, x2);  // check that x was changed
 
 	// test that reference members are not implicitly constructed/destructed/assigned
