Diff [54cd58b05627aa96eb079e979384aae60df8bd8e:92360603d942184e66e5f92706ecc75c6b04f121] for / – Cforall

src/CodeGen/CodeGenerator.cc

-                      r54cd58b
+                      r9236060
                         genCommaList( aggDecl->get_parameters().begin(), aggDecl->get_parameters().end() );
                         output << ")" << endl;
+                        output << indent;
+                }
 …
         void CodeGenerator::visit( __attribute__((unused)) ConstructorInit * init ){
                 assertf( ! genC, "ConstructorInit nodes should not reach code generation." );
+                // xxx - generate something reasonable for constructor/destructor pairs
+                output << "<ctorinit>";
+                // pseudo-output for constructor/destructor pairs
+                output << "<ctorinit>{" << std::endl << ++indent << "ctor: ";
+                maybeAccept( init->get_ctor(), *this );
+                output << ", " << std::endl << indent << "dtor: ";
+                maybeAccept( init->get_dtor(), *this );
+                output << std::endl << --indent << "}";
+        }
 …
                         if ( varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic && operatorLookup( varExpr->get_var()->get_name(), opInfo ) ) {
                                 std::list< Expression* >::iterator arg = applicationExpr->get_args().begin();
-                                switch ( opInfo.type ) {
-                                  case OT_PREFIXASSIGN:
-                                  case OT_POSTFIXASSIGN:
-                                  case OT_INFIXASSIGN:
-                                  case OT_CTOR:
-                                  case OT_DTOR:
+                                        {
-                                                assert( arg != applicationExpr->get_args().end() );
-                                                if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( *arg ) ) {
-                                                        // remove & from first assignment/ctor argument
-                                                        *arg = addrExpr->get_arg();
-                                                } else {
-                                                        // no address-of operator, so must be a pointer - add dereference
-                                                        // NOTE: if the assertion starts to trigger, check that the application expr isn't being shared.
-                                                        // Since its arguments are modified here, this assertion most commonly triggers when the application
-                                                        // is visited multiple times.
-                                                        UntypedExpr * newExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                                        newExpr->get_args().push_back( *arg );
-                                                        Type * type = InitTweak::getPointerBase( (*arg)->get_result() );
-                                                        assertf( type, "First argument to a derefence must be a pointer. Ensure that expressions are not being shared." );
-                                                        newExpr->set_result( type->clone() );
-                                                        *arg = newExpr;
-                                                } // if
-                                                break;
+                                        }
-                                  default:
-                                        // do nothing
+                                        ;
-                                } // switch
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
 …
                 extension( commaExpr );
                 output << "(";
+                if ( genC ) {
+                        // arg1 of a CommaExpr is never used, so it can be safely cast to void to reduce gcc warnings.
+                        commaExpr->set_arg1( new CastExpr( commaExpr->get_arg1() ) );
+                }
                 commaExpr->get_arg1()->accept( *this );
                 output << " , ";
 …
                 for ( Statement * stmt : stmts ) {
                         output << lineDirective( stmt ) << indent;
             output << printLabels( stmt->get_labels() );
+                        output << printLabels( stmt->get_labels() );
                         if ( i+1 == numStmts ) {
                                 // last statement in a statement expression needs to be handled specially -
 …
         void CodeGenerator::visit( ExprStmt * exprStmt ) {
                 assert( exprStmt );
-                Expression * expr = exprStmt->get_expr();
                 if ( genC ) {
                         // cast the top-level expression to void to reduce gcc warnings.
                         expr = new CastExpr( expr );
+                }
                 expr->accept( *this );
+                        exprStmt->set_expr( new CastExpr( exprStmt->get_expr() ) );
+                }
+                exprStmt->get_expr()->accept( *this );
                 output << ";";
+        }

src/CodeGen/CodeGenerator.h

r54cd58b	r9236060
19	19	#include <ostream> // for ostream, operator<<
20	20	#include <string> // for string
	21
	22	#include "Common/Indenter.h" // for Indenter
21	23
22	24	#include "SynTree/Declaration.h" // for DeclarationWithType (ptr only), Fun...

src/CodeGen/GenType.cc

-                      r54cd58b
+                      r9236060
                 virtual void visit( PointerType *pointerType );
                 virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
                 virtual void visit( StructInstType *structInst );
                 virtual void visit( UnionInstType *unionInst );
 …
+        }
+        void GenType::visit( ReferenceType *refType ) {
+                assert( refType->get_base() != 0);
+                assertf( ! genC, "Reference types should not reach code generation." );
+                handleQualifiers( refType );
+                typeString = "&" + typeString;
+                refType->get_base()->accept( *this );
+        }
         void GenType::visit( FunctionType *funcType ) {
                 std::ostringstream os;

src/CodeGen/OperatorTable.cc

-                      r54cd58b
+                      r9236060
 //
+#include <map>      // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>  // for pair
+#include <algorithm>  // for any_of
+#include <map>        // for map, _Rb_tree_const_iterator, map<>::const_iterator
+#include <utility>    // for pair
 #include "OperatorTable.h"
 …
                 } // if
+        }
+        /// determines if a given function name is one of the operator types between [begin, end)
+        template<typename Iterator>
+        bool isOperatorType( const std::string & funcName, Iterator begin, Iterator end ) {
+                OperatorInfo info;
+                if ( operatorLookup( funcName, info ) ) {
+                        return std::find( begin, end, info.type ) != end;
+                }
+                return false;
+        }
+        bool isConstructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isDestructor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isAssignment( const std::string & funcName ) {
+                static OperatorType types[] = { OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtor( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
+        bool isCtorDtorAssign( const std::string & funcName ) {
+                static OperatorType types[] = { OT_CTOR, OT_DTOR, OT_PREFIXASSIGN, OT_POSTFIXASSIGN, OT_INFIXASSIGN };
+                return isOperatorType( funcName, std::begin(types), std::end(types) );
+        }
 } // namespace CodeGen

src/CodeGen/OperatorTable.h

-                      r54cd58b
+                      r9236060
 // file "LICENCE" distributed with Cforall.
 //
 // OperatorTable.h --
+// OperatorTable.h --
 //
 // Author           : Richard C. Bilson
 …
         bool operatorLookup( std::string funcName, OperatorInfo &info );
+        bool isConstructor( const std::string & );
+        bool isDestructor( const std::string & );
+        bool isAssignment( const std::string & );
+        bool isCtorDtor( const std::string & );
+        bool isCtorDtorAssign( const std::string & );
 } // namespace CodeGen

src/Common/PassVisitor.h

-                      r54cd58b
+                      r9236060
         virtual void visit( PointerType *pointerType ) override final;
         virtual void visit( ArrayType *arrayType ) override final;
+        virtual void visit( ReferenceType *referenceType ) override final;
         virtual void visit( FunctionType *functionType ) override final;
         virtual void visit( StructInstType *aggregateUseType ) override final;
 …
         virtual Type* mutate( PointerType *pointerType ) override final;
         virtual Type* mutate( ArrayType *arrayType ) override final;
+        virtual Type* mutate( ReferenceType *referenceType ) override final;
         virtual Type* mutate( FunctionType *functionType ) override final;
         virtual Type* mutate( StructInstType *aggregateUseType ) override final;

src/Common/PassVisitor.impl.h

-                      r54cd58b
+                      r9236060
 template< typename pass_type >
+void PassVisitor< pass_type >::visit( ReferenceType * node ) {
+        VISIT_BODY( node );
+}
+template< typename pass_type >
 void PassVisitor< pass_type >::visit( FunctionType * node ) {
         VISIT_BODY( node );
 …
 template< typename pass_type >
+Type * PassVisitor< pass_type >::mutate( ReferenceType * node ) {
+        MUTATE_BODY( Type, node );
+}
+template< typename pass_type >
 Type * PassVisitor< pass_type >::mutate( FunctionType * node ) {
         MUTATE_BODY( Type, node );

src/Common/utility.h

-                      r54cd58b
+                      r9236060
 template< typename T1, typename T2 >
 struct group_iterate_t {
         group_iterate_t( const T1 & v1, const T2 & v2 ) : args(v1, v2) {
                 assertf(v1.size() == v2.size(), "group iteration requires containers of the same size.");
+        group_iterate_t( bool skipBoundsCheck, const T1 & v1, const T2 & v2 ) : args(v1, v2) {
+                assertf(skipBoundsCheck || v1.size() == v2.size(), "group iteration requires containers of the same size: <%lu, %lu>.", v1.size(), v2.size());
         };
 …
 };
+/// performs bounds check to ensure that all arguments are of the same length.
 template< typename... Args >
 group_iterate_t<Args...> group_iterate( Args &&... args ) {
+        return group_iterate_t<Args...>(std::forward<Args>( args )...);
+        return group_iterate_t<Args...>(false, std::forward<Args>( args )...);
+}
+/// does not perform a bounds check - requires user to ensure that iteration terminates when appropriate.
+template< typename... Args >
+group_iterate_t<Args...> unsafe_group_iterate( Args &&... args ) {
+        return group_iterate_t<Args...>(true, std::forward<Args>( args )...);
+}

src/Concurrency/Keywords.cc

-                      r54cd58b
+                      r9236060
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for deleteAll, map_range
+#include "InitTweak/InitTweak.h"   // for isConstructor
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "Parser/LinkageSpec.h"    // for Cforall
 #include "SymTab/AddVisit.h"       // for acceptAndAdd
 …
                         LinkageSpec::Cforall,
                         nullptr,
                         new PointerType(
+                        new ReferenceType(
                                 noQualifiers,
                                 new StructInstType(
 …
                 //Makes sure it's not a copy
                 PointerType* pty = dynamic_cast< PointerType * >( ty );
                 if( ! pty ) throw SemanticError( "Mutex argument must be of pointer/reference type ", arg );
+                ReferenceType* rty = dynamic_cast< ReferenceType * >( ty );
+                if( ! rty ) throw SemanticError( "Mutex argument must be of reference type ", arg );
                 //Make sure the we are pointing directly to a type
+                Type* base = pty->get_base();
+                if(  dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                Type* base = rty->get_base();
+                if( dynamic_cast< ReferenceType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
+                if( dynamic_cast< PointerType * >( base ) ) throw SemanticError( "Mutex argument have exactly one level of indirection ", arg );
                 //Make sure that typed isn't mutex
 …
                 Visitor::visit(decl);
                 if( ! InitTweak::isConstructor(decl->get_name()) ) return;
+                if( ! CodeGen::isConstructor(decl->get_name()) ) return;
                 DeclarationWithType * param = decl->get_functionType()->get_parameters().front();
+                auto ptr = dynamic_cast< PointerType * >( param->get_type() );
+                // if( ptr ) std::cerr << "FRED1" << std::endl;
+                auto type  = dynamic_cast< StructInstType * >( ptr->get_base() );
+                auto type  = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) );
                 // if( type ) std::cerr << "FRED2" << std::endl;
                 if( type && type->get_baseStruct()->is_thread() ) {

src/GenPoly/Box.cc

-                      r54cd58b
+                      r9236060
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
+#include "CodeGen/OperatorTable.h"
 #include "InitTweak/InitTweak.h"
 …
                         // To compound the issue, the right side can be *x, etc. because of lvalue-returning functions
                         if ( UntypedExpr * assign = dynamic_cast< UntypedExpr * >( commaExpr->get_arg1() ) ) {
                                 if ( InitTweak::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
+                                if ( CodeGen::isAssignment( InitTweak::getFunctionName( assign ) ) ) {
                                         assert( assign->get_args().size() == 2 );
                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( assign->get_args().back() ) ) {
 …
+                                                }
                                         } else {
                                                 throw SemanticError( "Cannot pass non-struct type for generic struct" );
+                                                throw SemanticError( "Cannot pass non-struct type for generic struct: ", argBaseType );
+                                        }
+                                }
 …
                                                 } // if
                                                 if ( baseType1 || baseType2 ) {
+                                                        delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
                                                         if ( appExpr->get_env() ) {
 …
                                                 assert( ! appExpr->get_args().empty() );
                                                 if ( isPolyType( appExpr->get_result(), scopeTyVars, env ) ) {
+                                                        // remove dereference from polymorphic types since they are boxed.
                                                         Expression *ret = appExpr->get_args().front();
+                                                        // fix expr type to remove pointer
                                                         delete ret->get_result();
                                                         ret->set_result( appExpr->get_result()->clone() );
 …
                         assert( appExpr->get_function()->has_result() );
                         PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
                         FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
 …
                                                         if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr->get_args().front() ) ) {
                                                                 assert( appExpr->get_function()->has_result() );
                                                                 PointerType *pointer = safe_dynamic_cast< PointerType *>( appExpr->get_function()->get_result() );
                                                                 FunctionType *function = safe_dynamic_cast< FunctionType *>( pointer->get_base() );
+                                                                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
+                                                                assert( function );
                                                                 needs = needsAdapter( function, scopeTyVars );
                                                         } // if
 …
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
+                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
+                        // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
-                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         if ( polytype || needs ) {
                                 Expression *ret = addrExpr->get_arg();
 …
                                 if ( adaptersDone.find( mangleName ) == adaptersDone.end() ) {
                                         std::string adapterName = makeAdapterName( mangleName );
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0 ) );
+                                        // adapter may not be used in body, pass along with unused attribute.
+                                        paramList.push_front( new ObjectDecl( adapterName, Type::StorageClasses(), LinkageSpec::C, 0, new PointerType( Type::Qualifiers(), makeAdapterType( *funType, scopeTyVars ) ), 0, { new Attribute( "unused" ) } ) );
                                         adaptersDone.insert( adaptersDone.begin(), mangleName );
+                                }
 …
                         std::list< DeclarationWithType *>::iterator last = funcType->get_parameters().begin();
                         std::list< DeclarationWithType *> inferredParams;
+                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0 );
+                        // size/align/offset parameters may not be used in body, pass along with unused attribute.
+                        ObjectDecl newObj( "", Type::StorageClasses(), LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ), 0,
+                                           { new Attribute( "unused" ) } );
                         ObjectDecl newPtr( "", Type::StorageClasses(), LinkageSpec::C, 0,
                                            new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt ) ), 0 );
 …
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
 //      *assert = (*assert)->acceptMutator( *this );
+                                        // assertion parameters may not be used in body, pass along with unused attribute.
+                                        (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
                                         inferredParams.push_back( *assert );
+                                }

src/GenPoly/Lvalue.cc

-                      r54cd58b
+                      r9236060
 #include "SynTree/Mutator.h"
 #include "SymTab/Indexer.h"
+#include "SymTab/Autogen.h"
 #include "ResolvExpr/Resolver.h"
 …
 #include "Common/UniqueName.h"
 #include "Common/utility.h"
+#include "Common/PassVisitor.h"
+#include "InitTweak/InitTweak.h"
+#if 0
+#define PRINT(x) x
+#else
+#define PRINT(x)
+#endif
 namespace GenPoly {
         namespace {
+                /// Replace uses of lvalue returns with appropriate pointers
+                class Pass1 : public Mutator {
+                  public:
+                        Pass1();
+                        virtual Expression *mutate( ApplicationExpr *appExpr );
+                        virtual Statement *mutate( ReturnStmt *appExpr );
+                        virtual DeclarationWithType *mutate( FunctionDecl *funDecl );
+                  private:
+                        DeclarationWithType* retval;
+                };
+                /// Replace declarations of lvalue returns with appropriate pointers
+                class Pass2 : public Visitor {
+                  public:
+                        virtual void visit( FunctionType *funType );
+                  private:
+                // TODO: fold this into the general createDeref function??
+                Expression * mkDeref( Expression * arg ) {
+                        if ( SymTab::dereferenceOperator ) {
+                                VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
+                                deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
+                                Type * base = InitTweak::getPointerBase( arg->get_result() );
+                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
+                                ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
+                                delete ret->get_result();
+                                ret->set_result( base->clone() );
+                                ret->get_result()->set_lvalue( true );
+                                return ret;
+                        } else {
+                                return UntypedExpr::createDeref( arg );
+                        }
+                }
+                struct ReferenceConversions final {
+                        Expression * postmutate( CastExpr * castExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                };
+                /// Intrinsic functions that take reference parameters don't REALLY take reference parameters -- their reference arguments must always be implicitly dereferenced.
+                struct FixIntrinsicArgs final {
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                };
+                struct FixIntrinsicResult final {
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                };
+                /// Replace reference types with pointer types
+                struct ReferenceTypeElimination final {
+                        Type * postmutate( ReferenceType * refType );
                 };
 …
                 /// https://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Lvalues.html#Lvalues
                 /// Replaces &(a,b) with (a, &b), &(a ? b : c) with (a ? &b : &c)
+                class GeneralizedLvalue : public Mutator {
+                        typedef Mutator Parent;
+                        virtual Expression * mutate( MemberExpr * memExpr );
+                        virtual Expression * mutate( AddressExpr * addressExpr );
+                struct GeneralizedLvalue final : public WithVisitorRef<GeneralizedLvalue> {
+                        Expression * postmutate( AddressExpr * addressExpr );
+                        Expression * postmutate( MemberExpr * memExpr );
                         template<typename Func>
                         Expression * applyTransformation( Expression * expr, Expression * arg, Func mkExpr );
                 };
+                /// Removes redundant &*/*& pattern that this pass can generate
+                struct CollapseAddrDeref final {
+                        Expression * postmutate( AddressExpr * addressExpr );
+                        Expression * postmutate( ApplicationExpr * appExpr );
+                };
+                struct AddrRef final : public WithGuards {
+                        void premutate( AddressExpr * addrExpr );
+                        Expression * postmutate( AddressExpr * addrExpr );
+                        void premutate( Expression * expr );
+                        bool first = true;
+                        bool current = false;
+                        int refDepth = 0;
+                };
         } // namespace
+        static bool referencesEliminated = false;
+        // used by UntypedExpr::createDeref to determine whether result type of dereference should be ReferenceType or value type.
+        bool referencesPermissable() {
+                return ! referencesEliminated;
+        }
         void convertLvalue( std::list< Declaration* >& translationUnit ) {
+                Pass1 p1;
+                Pass2 p2;
+                GeneralizedLvalue genLval;
+                mutateAll( translationUnit, p1 );
+                acceptAll( translationUnit, p2 );
+                std::cerr << "convertLvalue" << std::endl;
+                PassVisitor<ReferenceConversions> refCvt;
+                PassVisitor<ReferenceTypeElimination> elim;
+                PassVisitor<GeneralizedLvalue> genLval;
+                PassVisitor<FixIntrinsicArgs> fixer;
+                PassVisitor<CollapseAddrDeref> collapser;
+                PassVisitor<AddrRef> addrRef;
+                PassVisitor<FixIntrinsicResult> intrinsicResults;
+                mutateAll( translationUnit, intrinsicResults );
+                mutateAll( translationUnit, addrRef );
+                mutateAll( translationUnit, refCvt );
+                mutateAll( translationUnit, fixer );
+                mutateAll( translationUnit, collapser );
                 mutateAll( translationUnit, genLval );
+                mutateAll( translationUnit, elim );  // last because other passes need reference types to work
+                // from this point forward, no other pass should create reference types.
+                referencesEliminated = true;
+        }
         Expression * generalizedLvalue( Expression * expr ) {
                 GeneralizedLvalue genLval;
+                PassVisitor<GeneralizedLvalue> genLval;
                 return expr->acceptMutator( genLval );
+        }
         namespace {
+                Type* isLvalueRet( FunctionType *function ) {
+                        if ( function->get_returnVals().empty() ) return 0;
+                        Type *ty = function->get_returnVals().front()->get_type();
+                        return ty->get_lvalue() ? ty : 0;
+                }
+                bool isIntrinsicApp( ApplicationExpr *appExpr ) {
+                        if ( VariableExpr *varExpr = dynamic_cast< VariableExpr* >( appExpr->get_function() ) ) {
+                                return varExpr->get_var()->get_linkage() == LinkageSpec::Intrinsic;
+                        } else {
+                                return false;
+                        } // if
+                }
+                Pass1::Pass1() {
+                }
+                DeclarationWithType * Pass1::mutate( FunctionDecl *funcDecl ) {
+                        if ( funcDecl->get_statements() ) {
+                                DeclarationWithType* oldRetval = retval;
+                                retval = 0;
+                                if ( ! LinkageSpec::isBuiltin( funcDecl->get_linkage() ) && isLvalueRet( funcDecl->get_functionType() ) ) {
+                                        retval = funcDecl->get_functionType()->get_returnVals().front();
+                                }
+                                // fix expressions and return statements in this function
+                                funcDecl->set_statements( funcDecl->get_statements()->acceptMutator( *this ) );
+                                retval = oldRetval;
+                        } // if
+                        return funcDecl;
+                }
+                Expression * Pass1::mutate( ApplicationExpr *appExpr ) {
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+                        PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                        FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
+                        Type *funType = isLvalueRet( function );
+                        if ( funType && ! isIntrinsicApp( appExpr ) ) {
+                                Expression *expr = appExpr;
+                                Type *appType = appExpr->get_result();
+                                if ( isPolyType( funType ) && ! isPolyType( appType ) ) {
+                                        // make sure cast for polymorphic type is inside dereference
+                                        expr = new CastExpr( appExpr, new PointerType( Type::Qualifiers(), appType->clone() ) );
+                                }
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->set_result( appType->clone() );
+                                appExpr->set_result( new PointerType( Type::Qualifiers(), appType ) );
+                                deref->get_args().push_back( expr );
+                                return deref;
+                        } else {
+                                return appExpr;
+                        } // if
+                }
+                Statement * Pass1::mutate(ReturnStmt *retStmt) {
+                        if ( retval && retStmt->get_expr() ) {
+                                if ( retStmt->get_expr()->get_result()->get_lvalue() ) {
+                                        // ***** Code Removal ***** because casts may be stripped already
+                                        // strip casts because not allowed to take address of cast
+                                        // while ( CastExpr *castExpr = dynamic_cast< CastExpr* >( retStmt->get_expr() ) ) {
+                                        //      retStmt->set_expr( castExpr->get_arg() );
+                                        //      retStmt->get_expr()->set_env( castExpr->get_env() );
+                                        //      castExpr->set_env( 0 );
+                                        //      castExpr->set_arg( 0 );
+                                        //      delete castExpr;
+                                        // } // while
+                                        retStmt->set_expr( new AddressExpr( retStmt->get_expr()->acceptMutator( *this ) ) );
+                // true for intrinsic function calls that return a reference
+                bool isIntrinsicReference( Expression * expr ) {
+                        if ( UntypedExpr * untyped = dynamic_cast< UntypedExpr * >( expr ) ) {
+                                std::string fname = InitTweak::getFunctionName( untyped );
+                                // known intrinsic-reference prelude functions
+                                return fname == "*?" || fname == "?[?]";
+                        } else if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * > ( expr ) ) {
+                                if ( DeclarationWithType * func = InitTweak::getFunction( appExpr ) ) {
+                                        // use type of return variable rather than expr result type, since it may have been changed to a pointer type
+                                        FunctionType * ftype = GenPoly::getFunctionType( func->get_type() );
+                                        Type * ret = ftype->get_returnVals().empty() ? nullptr : ftype->get_returnVals().front()->get_type();
+                                        return func->get_linkage() == LinkageSpec::Intrinsic && dynamic_cast<ReferenceType *>( ret );
+                                }
+                        }
+                        return false;
+                }
+                Expression * FixIntrinsicResult::postmutate( ApplicationExpr * appExpr ) {
+                        if ( isIntrinsicReference( appExpr ) ) {
+                                // eliminate reference types from intrinsic applications - now they return lvalues
+                                Type * result = appExpr->get_result();
+                                appExpr->set_result( result->stripReferences()->clone() );
+                                appExpr->get_result()->set_lvalue( true );
+                                Expression * ret = new CastExpr( appExpr, result );
+                                ret->set_env( appExpr->get_env() );
+                                appExpr->set_env( nullptr );
+                                return ret;
+                        }
+                        return appExpr;
+                }
+                Expression * FixIntrinsicArgs::postmutate( ApplicationExpr * appExpr ) {
+                        // intrinsic functions don't really take reference-typed parameters, so they require an implicit dereference on their arguments.
+                        if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
+                                FunctionType * ftype = GenPoly::getFunctionType( function->get_type() );
+                                assertf( ftype, "Function declaration does not have function type." );
+                                // can be of differing lengths only when function is variadic
+                                assertf( ftype->get_parameters().size() == appExpr->get_args().size() || ftype->get_isVarArgs(), "ApplicationExpr args do not match formal parameter type." );
+                                unsigned int i = 0;
+                                const unsigned int end = ftype->get_parameters().size();
+                                for ( auto p : unsafe_group_iterate( appExpr->get_args(), ftype->get_parameters() ) ) {
+                                        if (i == end) break;
+                                        Expression *& arg = std::get<0>( p );
+                                        Type * formal = std::get<1>( p )->get_type();
+                                        PRINT(
+                                                std::cerr << "pair<0>: " << arg << std::endl;
+                                                std::cerr << "pair<1>: " << formal << std::endl;
+                                        )
+                                        if ( dynamic_cast<ReferenceType*>( formal ) ) {
+                                                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->get_result() );
+                                                        assertf( baseType, "parameter is reference, arg must be pointer or reference: %s", toString( arg->get_result() ).c_str() );
+                                                        PointerType * ptrType = new PointerType( Type::Qualifiers(), baseType->clone() );
+                                                        delete arg->get_result();
+                                                        arg->set_result( ptrType );
+                                                        arg = mkDeref( arg );
+                                                }
+                                        }
+                                        ++i;
+                                }
+                        }
+                        return appExpr;
+                }
+                // idea: &&&E: get outer &, inner &
+                // at inner &, record depth D of reference type
+                // at outer &, add D derefs.
+                void AddrRef::premutate( Expression * expr ) {
+                        GuardValue( current );
+                        GuardValue( first );
+                        current = false;
+                        first = true;
+                }
+                void AddrRef::premutate( AddressExpr * addrExpr ) {
+                        GuardValue( current );
+                        GuardValue( first );
+                        current = first;
+                        first = false;
+                        if ( current ) {
+                                GuardValue( refDepth );
+                                refDepth = 0;
+                        }
+                }
+                Expression * AddrRef::postmutate( AddressExpr * addrExpr ) {
+                        if ( refDepth == 0 ) {
+                                if ( ! isIntrinsicReference( addrExpr->get_arg() ) ) {
+                                        // try to avoid ?[?]
+                                        refDepth = addrExpr->get_arg()->get_result()->referenceDepth();
+                                }
+                        }
+                        if ( current ) {
+                                Expression * ret = addrExpr;
+                                while ( refDepth ) {
+                                        ret = mkDeref( ret );
+                                        refDepth--;
+                                }
+                                return ret;
+                        }
+                        return addrExpr;
+                }
+                Expression * ReferenceConversions::postmutate( AddressExpr * addrExpr ) {
+                        // Inner expression may have been lvalue to reference conversion, which becomes an address expression.
+                        // In this case, remove the outer address expression and return the argument.
+                        // TODO: It's possible that this might catch too much and require a more sophisticated check.
+                        return addrExpr;
+                }
+                Expression * ReferenceConversions::postmutate( CastExpr * castExpr ) {
+                        // xxx - is it possible to convert directly between reference types with a different base? E.g.,
+                        //   int x;
+                        //   (double&)x;
+                        // At the moment, I am working off of the assumption that this is illegal, thus the cast becomes redundant
+                        // after this pass, so trash the cast altogether. If that changes, care must be taken to insert the correct
+                        // pointer casts in the right places.
+                        // conversion to reference type
+                        if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_result() ) ) {
+                                (void)refType;
+                                if ( ReferenceType * otherRef = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                                        // nothing to do if casting from reference to reference.
+                                        (void)otherRef;
+                                        PRINT( std::cerr << "convert reference to reference -- nop" << std::endl; )
+                                        if ( isIntrinsicReference( castExpr->get_arg() ) ) {
+                                                Expression * callExpr = castExpr->get_arg();
+                                                PRINT(
+                                                        std::cerr << "but arg is deref -- &" << std::endl;
+                                                        std::cerr << callExpr << std::endl;
+                                                )
+                                                callExpr = new AddressExpr( callExpr ); // this doesn't work properly for multiple casts
+                                                delete callExpr->get_result();
+                                                callExpr->set_result( refType->clone() );
+                                                // move environment out to new top-level
+                                                callExpr->set_env( castExpr->get_env() );
+                                                castExpr->set_arg( nullptr );
+                                                castExpr->set_env( nullptr );
+                                                delete castExpr;
+                                                return callExpr;
+                                        }
+                                        int depth1 = refType->referenceDepth();
+                                        int depth2 = otherRef->referenceDepth();
+                                        assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
+                                        PRINT( std::cerr << castExpr << std::endl; )
+                                        return castExpr;
+                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
+                                        // conversion from lvalue to reference
+                                        // xxx - keep cast, but turn into pointer cast??
+                                        // xxx - memory
+                                        PRINT(
+                                                std::cerr << "convert lvalue to reference -- &" << std::endl;
+                                                std::cerr << castExpr->get_arg() << std::endl;
+                                        )
+                                        AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
+                                        if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
+                                                // must keep cast if cast-to type is different from the actual type
+                                                castExpr->set_arg( ret );
+                                                return castExpr;
+                                        }
+                                        ret->set_env( castExpr->get_env() );
+                                        delete ret->get_result();
+                                        ret->set_result( castExpr->get_result() );
+                                        castExpr->set_env( nullptr );
+                                        castExpr->set_arg( nullptr );
+                                        castExpr->set_result( nullptr );
+                                        delete castExpr;
+                                        return ret;
                                 } else {
+                                        throw SemanticError( "Attempt to return non-lvalue from an lvalue-qualified function" );
+                                } // if
+                        } // if
+                        return retStmt;
+                }
+                void Pass2::visit( FunctionType *funType ) {
+                        std::string typeName;
+                        if ( isLvalueRet( funType ) ) {
+                                DeclarationWithType *retParm = funType->get_returnVals().front();
+                                // make a new parameter that is a pointer to the type of the old return value
+                                retParm->set_type( new PointerType( Type::Qualifiers(), retParm->get_type() ) );
+                        } // if
+                        Visitor::visit( funType );
+                                        // rvalue to reference conversion -- introduce temporary
+                                }
+                                assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                                (void)refType;
+                                // conversion from reference to rvalue
+                                PRINT(
+                                        std::cerr << "convert reference to rvalue -- *" << std::endl;
+                                        std::cerr << "was = " << castExpr << std::endl;
+                                )
+                                Expression * ret = castExpr->get_arg();
+                                TypeSubstitution * env = castExpr->get_env();
+                                castExpr->set_env( nullptr );
+                                if ( ! isIntrinsicReference( ret ) ) {
+                                        // dereference if not already dereferenced
+                                        ret = mkDeref( ret );
+                                }
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                        // can remove cast if types are compatible, changing expression type to value type
+                                        ret->set_result( castExpr->get_result()->clone() );
+                                        castExpr->set_arg( nullptr );
+                                        delete castExpr;
+                                } else {
+                                        // must keep cast if types are different
+                                        castExpr->set_arg( ret );
+                                        ret = castExpr;
+                                }
+                                ret->set_env( env );
+                                PRINT( std::cerr << "now: " << ret << std::endl; )
+                                return ret;
+                        }
+                        return castExpr;
+                }
+                Type * ReferenceTypeElimination::postmutate( ReferenceType * refType ) {
+                        Type * base = refType->get_base();
+                        Type::Qualifiers qualifiers = refType->get_qualifiers();
+                        refType->set_base( nullptr );
+                        delete refType;
+                        return new PointerType( qualifiers, base );
+                }
 …
                                 Expression * arg1 = commaExpr->get_arg1()->clone();
                                 Expression * arg2 = commaExpr->get_arg2()->clone();
                                 Expression * ret = new CommaExpr( arg1, mkExpr( arg2 ) );
+                                Expression * ret = new CommaExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ) );
                                 ret->set_env( expr->get_env() );
                                 expr->set_env( nullptr );
                                 delete expr;
                                 return ret->acceptMutator( *this );
+                                return ret;
                         } else if ( ConditionalExpr * condExpr = dynamic_cast< ConditionalExpr * >( arg ) ) {
                                 Expression * arg1 = condExpr->get_arg1()->clone();
                                 Expression * arg2 = condExpr->get_arg2()->clone();
                                 Expression * arg3 = condExpr->get_arg3()->clone();
                                 ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 ), mkExpr( arg3 ) );
+                                ConditionalExpr * ret = new ConditionalExpr( arg1, mkExpr( arg2 )->acceptMutator( *visitor ), mkExpr( arg3 )->acceptMutator( *visitor ) );
                                 ret->set_env( expr->get_env() );
                                 expr->set_env( nullptr );
 …
                                 unify( ret->get_arg2()->get_result(), ret->get_arg3()->get_result(), newEnv, needAssertions, haveAssertions, openVars, SymTab::Indexer(), commonType );
                                 ret->set_result( commonType ? commonType : ret->get_arg2()->get_result()->clone() );
                                 return ret->acceptMutator( *this );
+                                return ret;
+                        }
                         return expr;
+                }
+                Expression * GeneralizedLvalue::mutate( MemberExpr * memExpr ) {
+                        Parent::mutate( memExpr );
+                Expression * GeneralizedLvalue::postmutate( MemberExpr * memExpr ) {
                         return applyTransformation( memExpr, memExpr->get_aggregate(), [=]( Expression * aggr ) { return new MemberExpr( memExpr->get_member(), aggr ); } );
+                }
+                Expression * GeneralizedLvalue::mutate( AddressExpr * addrExpr ) {
+                        addrExpr = safe_dynamic_cast< AddressExpr * >( Parent::mutate( addrExpr ) );
+                Expression * GeneralizedLvalue::postmutate( AddressExpr * addrExpr ) {
                         return applyTransformation( addrExpr, addrExpr->get_arg(), []( Expression * arg ) { return new AddressExpr( arg ); } );
+                }
+                Expression * CollapseAddrDeref::postmutate( AddressExpr * addrExpr ) {
+                        Expression * arg = addrExpr->get_arg();
+                        if ( isIntrinsicReference( arg ) ) {
+                                std::string fname = InitTweak::getFunctionName( arg );
+                                if ( fname == "*?" ) {
+                                        Expression *& arg0 = InitTweak::getCallArg( arg, 0 );
+                                        Expression * ret = arg0;
+                                        ret->set_env( addrExpr->get_env() );
+                                        arg0 = nullptr;
+                                        addrExpr->set_env( nullptr );
+                                        delete addrExpr;
+                                        return ret;
+                                }
+                        }
+                        return addrExpr;
+                }
+                Expression * CollapseAddrDeref::postmutate( ApplicationExpr * appExpr ) {
+                        if ( isIntrinsicReference( appExpr ) ) {
+                                std::string fname = InitTweak::getFunctionName( appExpr );
+                                if ( fname == "*?" ) {
+                                        Expression * arg = InitTweak::getCallArg( appExpr, 0 );
+                                        // xxx - this isn't right, because it can remove casts that should be there...
+                                        // while ( CastExpr * castExpr = dynamic_cast< CastExpr * >( arg ) ) {
+                                        //      arg = castExpr->get_arg();
+                                        // }
+                                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( arg ) ) {
+                                                Expression * ret = addrExpr->get_arg();
+                                                ret->set_env( appExpr->get_env() );
+                                                addrExpr->set_arg( nullptr );
+                                                appExpr->set_env( nullptr );
+                                                delete appExpr;
+                                                return ret;
+                                        }
+                                }
+                        }
+                        return appExpr;
+                }
         } // namespace

src/GenPoly/Lvalue.h

-                      r54cd58b
+                      r9236060
         void convertLvalue( std::list< Declaration* >& translationUnit );
+        /// true after reference types have been eliminated from the source code. After this point, reference types should not be added to the AST.
+        bool referencesPermissable();
         /// applies transformations that allow GCC to accept more complicated lvalue expressions, e.g. &(a, b)
         Expression * generalizedLvalue( Expression * expr );

src/GenPoly/Specialize.cc

-                      r54cd58b
+                      r9236060
                         // conversion of 0 (null) to function type does not require tuple specialization
                         if ( dynamic_cast< ZeroType * >( actualType ) ) return false;
                         FunctionType * aftype = getFunctionType( actualType );
                         assertf( aftype, "formal type is a function type, but actual type is not." );
+                        FunctionType * aftype = getFunctionType( actualType->stripReferences() );
+                        assertf( aftype, "formal type is a function type, but actual type is not: %s", toString( actualType ).c_str() );
                         if ( fftype->get_parameters().size() != aftype->get_parameters().size() ) return true;
                         for ( auto params : group_iterate( fftype->get_parameters(), aftype->get_parameters() ) ) {

src/InitTweak/FixInit.cc

-                      r54cd58b
+                      r9236060
 #include "FixGlobalInit.h"
 #include "CodeGen/GenType.h"  // for warning/error messages
+#include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"
 #include "GenPoly/DeclMutator.h"
 …
                         SemanticError errors;
                   private:
-                        void handleFirstParam( Expression * firstParam );
                         template< typename... Params >
                         void emit( CodeLocation, const Params &... params );
 …
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
                                         if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
                                                 PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                                                assert( t1 );
+                                                if ( ResolvExpr::typesCompatible( t1, t2, SymTab::Indexer() ) ) {
                                                         // optimization: don't need to copy construct in order to call a copy constructor
                                                         return appExpr;
                                                 } // if
                                         } else if ( isDestructor( funcDecl->get_name() ) ) {
+                                        } else if ( CodeGen::isDestructor( funcDecl->get_name() ) ) {
                                                 // correctness: never copy construct arguments to a destructor
                                                 return appExpr;
 …
                 bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
                         return dynamic_cast< VarArgsType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
 …
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! result->get_lvalue() ) {
+                                if ( ! dynamic_cast< ReferenceType * >( result ) ) {
                                         // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
 …
                         if ( ! funcDecl ) return false;
                         if ( ! funcDecl->get_statements() ) return false;
                         return isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                        return CodeGen::isCtorDtor( funcDecl->get_name() ) && ! LinkageSpec::isOverridable( funcDecl->get_linkage() );
+                }
 …
                         function = funcDecl;
                         isCtor = isConstructor( function->get_name() );
+                        isCtor = CodeGen::isConstructor( function->get_name() );
                         if ( checkWarnings( function ) ) {
                                 FunctionType * type = function->get_functionType();
                                 assert( ! type->get_parameters().empty() );
                                 thisParam = safe_dynamic_cast< ObjectDecl * >( type->get_parameters().front() );
                                 PointerType * ptrType = safe_dynamic_cast< PointerType * > ( thisParam->get_type() );
                                 StructInstType * structType = dynamic_cast< StructInstType * >( ptrType->get_base() );
+                                Type * thisType = getPointerBase( thisParam->get_type() );
+                                StructInstType * structType = dynamic_cast< StructInstType * >( thisType );
                                 if ( structType ) {
                                         structDecl = structType->get_baseStruct();
 …
                         if ( ! unhandled.empty() ) {
                                 // need to explicitly re-add function parameters in order to resolve copy constructors
+                                // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 enterScope();
                                 maybeAccept( function->get_functionType(), *this );
 …
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
                                         Expression * arg2 = 0;
                                         if ( isCopyConstructor( function ) ) {
 …
+                                        }
                                         InitExpander srcParam( arg2 );
+                                        SymTab::genImplicitCall( srcParam, new MemberExpr( field, deref ), function->get_name(), back_inserter( stmt ), field, isCtor );
+                                        // cast away reference type and construct field.
+                                        Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() );
+                                        Expression * memberDest = new MemberExpr( field, thisExpr );
+                                        SymTab::genImplicitCall( srcParam, memberDest, function->get_name(), back_inserter( stmt ), field, isCtor );
                                         assert( stmt.size() <= 1 );
 …
+                }
+                /// true if expr is effectively just the 'this' parameter
+                bool isThisExpression( Expression * expr, DeclarationWithType * thisParam ) {
+                        // TODO: there are more complicated ways to pass 'this' to a constructor, e.g. &*, *&, etc.
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
+                                return varExpr->get_var() == thisParam;
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * > ( expr ) ) {
+                                return isThisExpression( castExpr->get_arg(), thisParam );
+                        }
+                        return false;
+                }
+                /// returns a MemberExpr if expr is effectively just member access on the 'this' parameter, else nullptr
+                MemberExpr * isThisMemberExpr( Expression * expr, DeclarationWithType * thisParam ) {
+                        if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
+                                if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                        return memberExpr;
+                                }
+                        } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
+                                return isThisMemberExpr( castExpr->get_arg(), thisParam );
+                        }
+                        return nullptr;
+                }
                 void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) return;
 …
                                 Expression * firstParam = appExpr->get_args().front();
                                 if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( firstParam ) ) {
+                                if ( isThisExpression( firstParam, thisParam ) ) {
                                         // if calling another constructor on thisParam, assume that function handles
                                         // all members - if it doesn't a warning will appear in that function.
+                                        if ( varExpr->get_var() == thisParam ) {
+                                                unhandled.clear();
+                                        }
+                                } else {
+                                        // if first parameter is a member expression then
+                                        // remove the member from unhandled set.
+                                        handleFirstParam( firstParam );
+                                }
+                        }
+                        Parent::visit( appExpr );
+                }
+                void GenStructMemberCalls::handleFirstParam( Expression * firstParam ) {
+                        using namespace std;
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( firstParam ) ) {
+                                if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( addrExpr->get_arg() ) ) {
+                                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                                if ( varExpr->get_var() == thisParam ) {
+                                                                        unhandled.erase( memberExpr->get_member() );
+                                                                }
+                                                        }
+                                                }
+                                        unhandled.clear();
+                                } else if ( MemberExpr * memberExpr = isThisMemberExpr( firstParam, thisParam ) ) {
+                                        // if first parameter is a member expression on the this parameter,
+                                        // then remove the member from unhandled set.
+                                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                                unhandled.erase( memberExpr->get_member() );
+                                        }
+                                }
+                        }
+                        Parent::visit( appExpr );
+                }
 …
                         if ( ! isCtor ) return;
+                        if ( ApplicationExpr * deref = dynamic_cast< ApplicationExpr * >( memberExpr->get_aggregate() ) ) {
+                                if ( getFunctionName( deref ) == "*?" && deref->get_args().size() == 1 ) {
+                                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( deref->get_args().front() ) ) {
+                                                if ( varExpr->get_var() == thisParam ) {
+                                                        if ( unhandled.count( memberExpr->get_member() ) ) {
+                                                                // emit a warning because a member was used before it was constructed
+                                                                usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
+                                                        }
+                                                }
+                                        }
+                        if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
+                                if ( unhandled.count( memberExpr->get_member() ) ) {
+                                        // emit a warning because a member was used before it was constructed
+                                        usedUninit.insert( { memberExpr->get_member(), memberExpr->location } );
+                                }
+                        }
 …
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+                        delete ctorExpr;
                         Expression *& firstArg = callExpr->get_args().front();
+                        UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                        assign->get_args().push_back( new VariableExpr( tmp ) );
+                        assign->get_args().push_back( firstArg );
+                        assign->set_result( ctorExpr->get_result()->clone() );
+                        firstArg = assign;
+                        CommaExpr * commaExpr = new CommaExpr( callExpr, new VariableExpr( tmp ) );
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
+                        firstArg = new VariableExpr( tmp );
+                        // for constructor expr:
+                        //   T x;
+                        //   x{};
+                        // results in:
+                        //   T x;
+                        //   T & tmp;
+                        //   &tmp = &x, ?{}(tmp), tmp
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
-                        delete ctorExpr;
                         return commaExpr;
+                }

src/InitTweak/GenInit.cc

-                      r54cd58b
+                      r9236060
 #include "Common/PassVisitor.h"
+#include "CodeGen/OperatorTable.h"
 #include "GenPoly/DeclMutator.h"
 …
           protected:
                 FunctionType * ftype;
+                FunctionType * ftype = nullptr;
                 std::string funcName;
         };
 …
                 std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
+                // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && ! returnVals.front()->get_type()->get_lvalue() ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
+                        UntypedExpr *construct = new UntypedExpr( new NameExpr( "?{}" ) );
+                        construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
+                        construct->get_args().push_back( returnStmt->get_expr() );
+                        stmtsToAddBefore.push_back(new ExprStmt(noLabels, construct));
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
                         // return the retVal object
 …
         bool CtorDtor::isManaged( Type * type ) const {
+                // at least for now, references are never constructed
+                if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
                 ValueGuard< Type::Qualifiers > qualifiers( type->get_qualifiers() );
 …
         void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && isCtorDtor( dwt->get_name() ) ) {
+                if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
                         std::list< DeclarationWithType * > & params = GenPoly::getFunctionType( dwt->get_type() )->get_parameters();
                         assert( ! params.empty() );
+                        PointerType * type = safe_dynamic_cast< PointerType * >( params.front()->get_type() );
+                        managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
+                        Type * type = InitTweak::getPointerBase( params.front()->get_type() );
+                        assert( type );
+                        managedTypes.insert( SymTab::Mangler::mangle( type ) );
+                }
+        }

src/InitTweak/InitTweak.cc

-                      r54cd58b
+                      r9236060
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
                         increment->get_args().push_back( new AddressExpr( index->clone() ) );
+                        increment->get_args().push_back( index->clone() );
                         *out++ = new ExprStmt( noLabels, increment );
+                }
 …
                 template<typename CallExpr>
                 Expression *& callArg( CallExpr * callExpr, unsigned int pos ) {
                         if ( pos >= callExpr->get_args().size() ) assertf( false, "asking for argument that doesn't exist. Return NULL/throw exception?" );
+                        if ( pos >= callExpr->get_args().size() ) assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", pos, toString( callExpr ).c_str() );
                         for ( Expression *& arg : callExpr->get_args() ) {
                                 if ( pos == 0 ) return arg;
 …
                 } else if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
                         return arrayType->get_base();
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
+                        return refType->get_base();
                 } else {
                         return NULL;
 …
                 if ( ftype->get_parameters().size() != 2 ) return 0;
                 Type * t1 = ftype->get_parameters().front()->get_type();
+                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
                 Type * t2 = ftype->get_parameters().back()->get_type();
+                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                assert( ptrType );
+                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                assert( t1 );
+                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, SymTab::Indexer() ) ) {
                         return function;
                 } else {

src/InitTweak/InitTweak.h

-                      r54cd58b
+                      r9236060
 // helper functions for initialization
 namespace InitTweak {
-        bool isConstructor( const std::string & );
-        bool isDestructor( const std::string & );
-        bool isAssignment( const std::string & );
-        bool isCtorDtor( const std::string & );
-        bool isCtorDtorAssign( const std::string & );
         FunctionDecl * isAssignment( Declaration * decl );
         FunctionDecl * isDestructor( Declaration * decl );

src/Makefile.in

-                      r54cd58b
+                      r9236060
         SynTree/driver_cfa_cpp-PointerType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT) \
         SynTree/driver_cfa_cpp-ReferenceToType.$(OBJEXT) \
 …
         SynTree/VoidType.cc SynTree/BasicType.cc \
         SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
+        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
+        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
 …
 SynTree/driver_cfa_cpp-ArrayType.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-ReferenceType.$(OBJEXT):  \
+        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-FunctionType.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 …
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-PointerType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceToType.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-Statement.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-TupleExpr.Po@am__quote@
 …
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ArrayType.obj `if test -f 'SynTree/ArrayType.cc'; then $(CYGPATH_W) 'SynTree/ArrayType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ArrayType.cc'; fi`
+SynTree/driver_cfa_cpp-ReferenceType.o: SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.o `test -f 'SynTree/ReferenceType.cc' || echo '$(srcdir)/'`SynTree/ReferenceType.cc
+SynTree/driver_cfa_cpp-ReferenceType.obj: SynTree/ReferenceType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-ReferenceType.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-ReferenceType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/ReferenceType.cc' object='SynTree/driver_cfa_cpp-ReferenceType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-ReferenceType.obj `if test -f 'SynTree/ReferenceType.cc'; then $(CYGPATH_W) 'SynTree/ReferenceType.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/ReferenceType.cc'; fi`
 SynTree/driver_cfa_cpp-FunctionType.o: SynTree/FunctionType.cc

src/Parser/DeclarationNode.cc

-                      r54cd58b
+                      r9236060
 } // DeclarationNode::newTypeDecl
 DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers ) {
         DeclarationNode * newnode = new DeclarationNode;
         newnode->type = new TypeData( TypeData::Pointer );
+DeclarationNode * DeclarationNode::newPointer( DeclarationNode * qualifiers, OperKinds kind ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( kind == OperKinds::PointTo ? TypeData::Pointer : TypeData::Reference );
         if ( qualifiers ) {
                 return newnode->addQualifiers( qualifiers );
 …
 DeclarationNode * DeclarationNode::addPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
+                assert( p->type->kind == TypeData::Pointer || TypeData::Reference );
                 setBase( p->type );
                 p->type = nullptr;
 …
 DeclarationNode * DeclarationNode::addNewPointer( DeclarationNode * p ) {
         if ( p ) {
                 assert( p->type->kind == TypeData::Pointer );
+                assert( p->type->kind == TypeData::Pointer || p->type->kind == TypeData::Reference );
                 if ( type ) {
                         switch ( type->kind ) {

src/Parser/ExpressionNode.cc

-                      r54cd58b
+                      r9236060
 Expression * build_unary_ptr( OperKinds op, ExpressionNode * expr_node ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node) ) );
+        args.push_back(  maybeMoveBuild< Expression >(expr_node) ); // xxx
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );
 } // build_unary_ptr
 …
 Expression * build_binary_ptr( OperKinds op, ExpressionNode * expr_node1, ExpressionNode * expr_node2 ) {
         std::list< Expression * > args;
         args.push_back( new AddressExpr( maybeMoveBuild< Expression >(expr_node1) ) );
+        args.push_back( maybeMoveBuild< Expression >(expr_node1) );
         args.push_back( maybeMoveBuild< Expression >(expr_node2) );
         return new UntypedExpr( new NameExpr( OperName[ (int)op ] ), args );

src/Parser/ParseNode.h

r54cd58b	r9236060
237	237	static DeclarationNode * newTraitUse( const std::string * name, ExpressionNode * params );
238	238	static DeclarationNode * newTypeDecl( std::string * name, DeclarationNode * typeParams );
239		static DeclarationNode * newPointer( DeclarationNode * qualifiers );
	239	static DeclarationNode * newPointer( DeclarationNode * qualifiers, OperKinds kind );
240	240	static DeclarationNode * newArray( ExpressionNode * size, DeclarationNode * qualifiers, bool isStatic );
241	241	static DeclarationNode * newVarArray( DeclarationNode * qualifiers );

src/Parser/TypeData.cc

-                      r54cd58b
+                      r9236060
           case Unknown:
           case Pointer:
+          case Reference:
           case EnumConstant:
                 // nothing else to initialize
 …
           case Unknown:
           case Pointer:
+          case Reference:
           case EnumConstant:
                 // nothing to destroy
 …
           case EnumConstant:
           case Pointer:
+          case Reference:
                 // nothing else to copy
                 break;
 …
                         // add dtor:  void ^?{}(T *)
                         FunctionType * dtorType = new FunctionType( Type::Qualifiers(), false );
                         dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        dtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "^?{}", Type::StorageClasses(), LinkageSpec::Cforall, dtorType, nullptr ) );
                         // add copy ctor:  void ?{}(T *, T)
                         FunctionType * copyCtorType = new FunctionType( Type::Qualifiers(), false );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         copyCtorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, copyCtorType, nullptr ) );
 …
                         // add default ctor:  void ?{}(T *)
                         FunctionType * ctorType = new FunctionType( Type::Qualifiers(), false );
                         ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        ctorType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         td->get_assertions().push_front( new FunctionDecl( "?{}", Type::StorageClasses(), LinkageSpec::Cforall, ctorType, nullptr ) );
                         // add assignment operator:  T * ?=?(T *, T)
                         FunctionType * assignType = new FunctionType( Type::Qualifiers(), false );
                         assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
+                        assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), new TypeInstType( Type::Qualifiers(), td->get_name(), *i ) ), nullptr ) );
                         assignType->get_parameters().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
                         assignType->get_returnVals().push_back( new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new TypeInstType( Type::Qualifiers(), td->get_name(), *i ), nullptr ) );
 …
           case TypeData::Array:
                 return buildArray( td );
+          case TypeData::Reference:
+                return buildReference( td );
           case TypeData::Function:
                 return buildFunction( td );
 …
         buildForall( td->forall, at->get_forall() );
         return at;
+} // buildPointer
+} // buildArray
+ReferenceType * buildReference( const TypeData * td ) {
+        ReferenceType * rt;
+        if ( td->base ) {
+                rt = new ReferenceType( buildQualifiers( td ), typebuild( td->base ) );
+        } else {
+                rt = new ReferenceType( buildQualifiers( td ), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+        } // if
+        buildForall( td->forall, rt->get_forall() );
+        return rt;
+} // buildReference
 AggregateDecl * buildAggregate( const TypeData * td, std::list< Attribute * > attributes, LinkageSpec::Spec linkage ) {

src/Parser/TypeData.h

-                      r54cd58b
+                      r9236060
 struct TypeData {
         enum Kind { Basic, Pointer, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
+        enum Kind { Basic, Pointer, Array, Reference, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
                                 SymbolicInst, Tuple, Typeof, Builtin, Unknown };
 …
 PointerType * buildPointer( const TypeData * );
 ArrayType * buildArray( const TypeData * );
+ReferenceType * buildReference( const TypeData * );
 AggregateDecl * buildAggregate( const TypeData *, std::list< Attribute * > );
 ReferenceToType * buildComAggInst( const TypeData *, std::list< Attribute * > attributes, LinkageSpec::Spec linkage );

src/Parser/lex.ll

r54cd58b	r9236060
236	236	__label__ { KEYWORD_RETURN(LABEL); } // GCC
237	237	long { KEYWORD_RETURN(LONG); }
238		~~lvalue { KEYWORD_RETURN(LVALUE); } // CFA~~
239	238	monitor { KEYWORD_RETURN(MONITOR); } // CFA
240	239	mutex { KEYWORD_RETURN(MUTEX); } // CFA

src/Parser/parser.yy

-                      r54cd58b
+                      r9236060
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
 %token FORALL LVALUE MUTEX VIRTUAL                                              // CFA
+%token FORALL MUTEX VIRTUAL                                             // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
 …
         conditional_expression
         | unary_expression assignment_operator assignment_expression
                 { $$ = new ExpressionNode( build_binary_ptr( $2, $1, $3 ) ); }
+                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+        ;
 …
         | VOLATILE
                 { $$ = DeclarationNode::newTypeQualifier( Type::Volatile ); }
-        | LVALUE                                                                                        // CFA
-                { $$ = DeclarationNode::newTypeQualifier( Type::Lvalue ); }
         | MUTEX
                 { $$ = DeclarationNode::newTypeQualifier( Type::Mutex ); }
 …
 variable_ptr:
         ptrref_operator variable_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' variable_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
 …
 function_ptr:
         ptrref_operator function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' function_ptr ')'
                 { $$ = $2; }
 …
 KR_function_ptr:
         ptrref_operator KR_function_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list KR_function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' KR_function_ptr ')'
                 { $$ = $2; }
 …
 type_ptr:
         ptrref_operator variable_type_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 identifier_parameter_ptr:
         ptrref_operator identifier_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' identifier_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 type_parameter_ptr:
         ptrref_operator type_parameter_redeclarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' abstract_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 abstract_parameter_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( nullptr ); }
+                { $$ = DeclarationNode::newPointer( nullptr, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator abstract_parameter_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( nullptr, $1 ) ); }
         | ptrref_operator type_qualifier_list abstract_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' abstract_parameter_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
 variable_abstract_ptr:
         ptrref_operator
                 { $$ = DeclarationNode::newPointer( 0 ); }
+                { $$ = DeclarationNode::newPointer( 0, $1 ); }
         | ptrref_operator type_qualifier_list
                 { $$ = DeclarationNode::newPointer( $2 ); }
+                { $$ = DeclarationNode::newPointer( $2, $1 ); }
         | ptrref_operator variable_abstract_declarator
                 { $$ = $2->addPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2 ) ); }
+                { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' variable_abstract_ptr ')' attribute_list_opt
                 { $$ = $2->addQualifiers( $4 ); }
 …
                 // No SUE declaration in parameter list.
         ptrref_operator type_specifier_nobody
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier_nobody
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_identifier_parameter_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
+        ;
 …
 cfa_abstract_ptr:                                                                               // CFA
         ptrref_operator type_specifier
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator type_specifier
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_function
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_function
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
         | ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0 ) ); }
+                { $$ = $2->addNewPointer( DeclarationNode::newPointer( 0, $1 ) ); }
         | type_qualifier_list ptrref_operator cfa_abstract_declarator_tuple
                 { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1 ) ); }
+                { $$ = $3->addNewPointer( DeclarationNode::newPointer( $1, $2 ) ); }
+        ;

src/ResolvExpr/Alternative.cc

-                      r54cd58b
+                      r9236060
                 : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
+        Alternative::Alternative( const Alternative &other ) {
+                initialize( other, *this );
+        Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
+        }
         Alternative &Alternative::operator=( const Alternative &other ) {
                 if ( &other == this ) return *this;
+                initialize( other, *this );
+                delete expr;
+                cost = other.cost;
+                cvtCost = other.cvtCost;
+                expr = maybeClone( other.expr );
+                env = other.env;
                 return *this;
+        }
 …
                 other.expr = nullptr;
                 return *this;
+        }
-        void Alternative::initialize( const Alternative &src, Alternative &dest ) {
-                dest.cost = src.cost;
-                dest.cvtCost = src.cvtCost;
-                dest.expr = maybeClone( src.expr );
-                dest.env = src.env;
+        }

src/ResolvExpr/Alternative.h

r54cd58b	r9236060
35	35	~Alternative();
36	36
37		~~void initialize( const Alternative &src, Alternative &dest );~~
38
39	37	void print( std::ostream &os, int indent = 0 ) const;
40	38

src/ResolvExpr/AlternativeFinder.cc

-                      r54cd58b
+                      r9236060
         Cost sumCost( const AltList &in ) {
                 Cost total;
+                Cost total = Cost::zero;
                 for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
                         total += i->cost;
 …
                         expr->get_result()->accept( global_renamer );
+                }
+        }
+                void referenceToRvalueConversion( Expression *& expr ) {
+                        if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                                // cast away reference from expr
+                                expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() );
+                        }
+                }
+        } // namespace
         template< typename InputIterator, typename OutputIterator >
 …
         void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
                 // adds anonymous member interpretations whenever an aggregate value type is seen.
+                Expression * expr = alt.expr->clone();
+                std::unique_ptr< Expression > manager( expr ); // RAII for expr
+                alt.env.apply( expr->get_result() );
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( expr->get_result() ) ) {
+                // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                std::unique_ptr<Expression> aggrExpr( alt.expr->clone() );
+                alt.env.apply( aggrExpr->get_result() );
+                Type * aggrType = aggrExpr->get_result();
+                if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                        aggrType = aggrType->stripReferences();
+                        aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                }
+                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
                         addAggMembers( structInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( expr->get_result() ) ) {
+                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
+                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
                         NameExpr nameExpr( "" );
                         addAggMembers( unionInst, expr, alt.cost+Cost( 0, 0, 1 ), alt.env, &nameExpr );
+                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, &nameExpr );
                 } // if
+        }
 …
                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                 Cost convCost( 0, 0, 0 );
+                Cost convCost = Cost::zero;
                 std::list< DeclarationWithType* >& formals = function->get_parameters();
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
 …
                                 actualType->print( std::cerr, 8 );
+                        )
                         Cost actualCost;
+                        Cost actualCost = Cost::zero;
                         if ( formal == formals.end() ) {
                                 if ( function->get_isVarArgs() ) {
+                                        convCost += Cost( 1, 0, 0 );
+                                        convCost.incUnsafe();
+                                        // convert reference-typed expressions to value-typed expressions
+                                        referenceToRvalueConversion( *actualExpr );
                                         continue;
                                 } else {
 …
                                 std::cerr << std::endl << " to ";
                                 formalType->print( std::cerr, 8 );
+                                std::cerr << std::endl << "environment is: ";
+                                alt.env.print( std::cerr, 8 );
+                                std::cerr << std::endl;
+                        )
                         Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
 …
                         convCost += newCost;
                         actualCost += newCost;
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
+                        if ( actualCost != Cost::zero ) {
                                 Type *newType = formalType->clone();
                                 alt.env.apply( newType );
                                 *actualExpr = new CastExpr( *actualExpr, newType );
+                        }
                         convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ) );
                         ++formal; // can't be in for-loop update because of the continue
+                }
 …
+                        }
                         convCost += newCost;
                         convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
+                        convCost.incPoly( polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ) );
+                }
 …
                         Expression * actual = actualIt->expr;
                         Type * actualType = actual->get_result();
                         PRINT(
                                 std::cerr << "formal type is ";
 …
+                        )
                         if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                // std::cerr << "unify failed" << std::endl;
                                 return false;
+                        }
 …
                         // match flattened actuals with formal parameters - actuals will be grouped to match
                         // with formals as appropriate
                         Cost cost;
+                        Cost cost = Cost::zero;
                         std::list< Expression * > newExprs;
                         ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
 …
                         makeExprList( instantiatedActuals, appExpr->get_args() );
                         PRINT(
+                                std::cerr << "instantiate function success: " << appExpr << std::endl;
                                 std::cerr << "need assertions:" << std::endl;
                                 printAssertionSet( resultNeed, std::cerr, 8 );
 …
                                 UntypedExpr *vexpr = untypedExpr->clone();
                                 vexpr->set_result( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
+                                alternatives.push_back( Alternative( vexpr, env, Cost::zero) );
                                 return;
+                        }
 …
                 AltList candidates;
                 SemanticError errors;
                 for ( AltList::const_iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
+                for ( AltList::iterator func = funcFinder.alternatives.begin(); func != funcFinder.alternatives.end(); ++func ) {
                         try {
                                 PRINT(
 …
+                                )
                                 // check if the type is pointer to function
+                                PointerType *pointer;
+                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
+                                if ( PointerType *pointer = dynamic_cast< PointerType* >( func->expr->get_result()->stripReferences() ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                referenceToRvalueConversion( func->expr );
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                         // XXX
 …
                                                         makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                }
+                                        } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( pointer->get_base() ) ) {
+                                                EqvClass eqvClass;
+                                                if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                        if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                                for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                        makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                                } // for
+                                                        } // if
+                                        }
+                                } else if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( func->expr->get_result()->stripReferences() ) ) { // handle ftype (e.g. *? on function pointer)
+                                        referenceToRvalueConversion( func->expr );
+                                        EqvClass eqvClass;
+                                        if ( func->env.lookup( typeInst->get_name(), eqvClass ) && eqvClass.type ) {
+                                                if ( FunctionType *function = dynamic_cast< FunctionType* >( eqvClass.type ) ) {
+                                                        for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
+                                                                makeFunctionAlternatives( *func, function, *actualAlt, std::back_inserter( candidates ) );
+                                                        } // for
                                                 } // if
                                         } // if
 …
+                                        }
                                         for ( AltList::const_iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
+                                        for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin(); funcOp != funcOpFinder.alternatives.end(); ++funcOp ) {
                                                 // check if the type is pointer to function
+                                                PointerType *pointer;
+                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
+                                                if ( PointerType *pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result()->stripReferences() ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
+                                                                referenceToRvalueConversion( funcOp->expr );
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
                                                                         AltList currentAlt;
 …
                                 PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
                                 FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                                 std::cerr << "Case +++++++++++++" << std::endl;
+                                std::cerr << "Case +++++++++++++ " << appExpr->get_function() << std::endl;
                                 std::cerr << "formals are:" << std::endl;
                                 printAll( function->get_parameters(), std::cerr, 8 );
 …
         bool isLvalue( Expression *expr ) {
                 // xxx - recurse into tuples?
                 return expr->has_result() && expr->get_result()->get_lvalue();
+                return expr->has_result() && ( expr->get_result()->get_lvalue() || dynamic_cast< ReferenceType * >( expr->get_result() ) );
+        }
 …
         Expression * restructureCast( Expression * argExpr, Type * toType ) {
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() ) {
+                        // Argument expression is a tuple and the target type is not void. Cast each member of the tuple
+                        // to its corresponding target type, producing the tuple of those cast expressions. If there are
+                        // more components of the tuple than components in the target type, then excess components do not
+                        // come out in the result expression (but UniqueExprs ensure that side effects will still be done).
+                if ( argExpr->get_result()->size() > 1 && ! toType->isVoid() && ! dynamic_cast<ReferenceType *>( toType ) ) {
+                        // Argument expression is a tuple and the target type is not void and not a reference type.
+                        // Cast each member of the tuple to its corresponding target type, producing the tuple of those
+                        // cast expressions. If there are more components of the tuple than components in the target type,
+                        // then excess components do not come out in the result expression (but UniqueExprs ensure that
+                        // side effects will still be done).
                         if ( Tuples::maybeImpure( argExpr ) && ! dynamic_cast< UniqueExpr * >( argExpr ) ) {
                                 // expressions which may contain side effects require a single unique instance of the expression.
 …
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
                         int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = i->expr->get_result()->size() - castExpr->get_result()->size();
                         if ( discardedValues < 0 ) continue;
                         // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
                         // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
                         // unification run for side-effects
                         unify( castExpr->get_result(), (*i).expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
                         Cost thisCost = castCost( (*i).expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env );
                         if ( thisCost != Cost::infinity ) {
                                 // count one safe conversion for each value that is thrown away
                                 thisCost += Cost( 0, 0, discardedValues );
+                                thisCost.incSafe( discardedValues );
                                 candidates.push_back( Alternative( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost ) );
 …
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
+                                addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
+                        std::unique_ptr<Expression> aggrExpr( agg->expr->clone() );
+                        Type * aggrType = aggrExpr->get_result();
+                        if ( dynamic_cast< ReferenceType * >( aggrType ) ) {
+                                aggrType = aggrType->stripReferences();
+                                aggrExpr.reset( new CastExpr( aggrExpr.release(), aggrType->clone() ) );
+                        }
+                        // find member of the given type
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( structInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
+                                addAggMembers( unionInst, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
+                                addTupleMembers( tupleType, aggrExpr.get(), agg->cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
 …
                 for ( std::list< DeclarationWithType* >::iterator i = declList.begin(); i != declList.end(); ++i ) {
                         VariableExpr newExpr( *i, nameExpr->get_argName() );
                         alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                        alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                         PRINT(
                                 std::cerr << "decl is ";
 …
                         for ( std::list< DeclarationWithType* >::iterator i = attrList.begin(); i != attrList.end(); ++i ) {
                                 VariableExpr newExpr( *i );
                                 alternatives.push_back( Alternative( newExpr.clone(), env, Cost() ) );
+                                alternatives.push_back( Alternative( newExpr.clone(), env, Cost::zero ) );
                                 renameTypes( alternatives.back().expr );
                         } // for
 …
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away
                                         thisCost += Cost( 0, 0, discardedValues );
+                                        thisCost.incSafe( discardedValues );
                                         candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
+                                }

src/ResolvExpr/CastCost.cc

-                      r54cd58b
+                      r9236060
                                 assert( type );
                                 if ( type->get_base() ) {
                                         return castCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
                 } // if
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
                         return Cost( 0, 0, 0 );
+                        return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                        return Cost::safe;
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         CastCost converter( dest, indexer, env );
 …
                         } else {
                                 // xxx - why are we adding cost 0 here?
                                 return converter.get_cost() + Cost( 0, 0, 0 );
+                                return converter.get_cost() + Cost::zero;
                         } // if
                 } // if
 …
                 if ( destAsPointer && basicType->isInteger() ) {
                         // necessary for, e.g. unsigned long => void*
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else {
                         ConversionCost::visit( basicType );
+                        cost = conversionCost( basicType, dest, indexer, env );
                 } // if
+        }
 …
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
                                 cost = Cost( 0, 0, 1 );
+                                cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
 …
                                 int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost( 0, 0, 1 );
+                                        cost = Cost::safe;
                                 } else if ( castResult < 0 ) {
                                         cost = Cost::infinity;
 …
                         if ( destAsBasic->isInteger() ) {
                                 // necessary for, e.g. void* => unsigned long
                                 cost = Cost( 1, 0, 0 );
+                                cost = Cost::unsafe;
                         } // if
+                }

src/ResolvExpr/CommonType.cc

-                      r54cd58b
+                      r9236060
 #include "SynTree/Type.h"
 #include "Unify.h"
 /// #define DEBUG
 …
                 virtual void visit( PointerType *pointerType );
                 virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
                 virtual void visit( FunctionType *functionType );
                 virtual void visit( StructInstType *aggregateUseType );
 …
                 virtual void visit( OneType *oneType );
+                void getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer );
+                template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
+                template< typename RefType > void handleRefType( RefType *inst, Type *other );
                 Type *result;
 …
         };
+        Type * handleReference( ReferenceType * refType, Type * other, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment & env, const OpenVarSet &openVars ) {
+                Type * result = nullptr, * common = nullptr;
+                AssertionSet have, need;
+                OpenVarSet newOpen( openVars );
+                // need unify to bind type variables
+                if ( unify( refType->get_base(), other, env, have, need, newOpen, indexer, common ) ) {
+                        // std::cerr << "unify success" << std::endl;
+                        if ( widenSecond ) {
+                                if ( widenFirst || other->get_qualifiers() <= refType->get_qualifiers() ) {
+                                        result = new ReferenceType( refType->get_qualifiers(), common ); // refType->clone();
+                                        result->get_qualifiers() |= other->get_qualifiers();
+                                }
+                        } else if ( widenFirst ) {
+                                if ( widenSecond || refType->get_qualifiers() <= other->get_qualifiers() ) {
+                                        result = common;
+                                        result->get_qualifiers() |= refType->get_qualifiers();
+                                }
+                        }
+                } else {
+                        // std::cerr << "exact unify failed: " << refType << " " << other << std::endl;
+                }
+                // std::cerr << "common type of reference [" << refType << "] and non-reference [" << other << "] is [" << result << "]" << std::endl;
+                return result;
+        }
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
                 CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
+                int depth1 = type1->referenceDepth();
+                int depth2 = type2->referenceDepth();
+                if ( depth1 > 0 || depth2 > 0 ) {
+                        int diff = depth1-depth2;
+                        // TODO: should it be possible for commonType to generate complicated conversions? I would argue no, only conversions that involve types of the same reference level or a difference of 1 should be allowed.
+                        if ( diff > 1 || diff < -1 ) return nullptr;
+                        // special case where one type has a reference depth of 1 larger than the other
+                        if ( diff > 0 ) {
+                                return handleReference( safe_dynamic_cast<ReferenceType *>( type1 ), type2, widenFirst, widenSecond, indexer, env, openVars );
+                        } else if ( diff < 0 ) {
+                                return handleReference( safe_dynamic_cast<ReferenceType *>( type2 ), type1, widenSecond, widenFirst, indexer, env, openVars );
+                        }
+                        // otherwise, both are reference types of the same depth and this is handled by the CommonType visitor.
+                }
                 type1->accept( visitor );
                 Type *result = visitor.get_result();
 …
+        }
+        void CommonType::getCommonWithVoidPointer( PointerType* voidPointer, PointerType* otherPointer ) {
+        template< typename Pointer >
+        void CommonType::getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer ) {
                 if ( TypeInstType* var = dynamic_cast< TypeInstType* >( otherPointer->get_base() ) ) {
                         OpenVarSet::const_iterator entry = openVars.find( var->get_name() );
 …
         void CommonType::visit( __attribute((unused)) ArrayType *arrayType ) {}
+        void CommonType::visit( ReferenceType *refType ) {
+                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
+                        if ( widenFirst && dynamic_cast< VoidType* >( otherRef->get_base() ) && ! isFtype(refType->get_base()) ) {
+                                getCommonWithVoidPointer( otherRef, refType );
+                        } else if ( widenSecond && dynamic_cast< VoidType* >( refType->get_base() ) && ! isFtype(otherRef->get_base()) ) {
+                                getCommonWithVoidPointer( refType, otherRef );
+                        } else if ( ( refType->get_base()->get_qualifiers() >= otherRef->get_base()->get_qualifiers() || widenFirst )
+                                           && ( refType->get_base()->get_qualifiers() <= otherRef->get_base()->get_qualifiers() || widenSecond ) ) {
+                                Type::Qualifiers tq1 = refType->get_base()->get_qualifiers(), tq2 = otherRef->get_base()->get_qualifiers();
+                                refType->get_base()->get_qualifiers() = Type::Qualifiers();
+                                otherRef->get_base()->get_qualifiers() = Type::Qualifiers();
+                                AssertionSet have, need;
+                                OpenVarSet newOpen( openVars );
+                                if ( unifyExact( refType->get_base(), otherRef->get_base(), env, have, need, newOpen, indexer ) ) {
+                                        if ( tq1 < tq2 ) {
+                                                result = refType->clone();
+                                        } else {
+                                                result = otherRef->clone();
+                                        } // if
+                                        result->get_qualifiers() = tq1 | tq2;
+                                } else {
+                                        /// std::cout << "place for ptr-to-type" << std::endl;
+                                } // if
+                                refType->get_base()->get_qualifiers() = tq1;
+                                otherRef->get_base()->get_qualifiers() = tq2;
+                        } // if
+                } else if ( widenSecond && dynamic_cast< ZeroType* >( type2 ) ) {
+                        result = refType->clone();
+                        result->get_qualifiers() |= type2->get_qualifiers();
+                } // if
+        }
         void CommonType::visit( __attribute((unused)) FunctionType *functionType ) {}
         void CommonType::visit( __attribute((unused)) StructInstType *aggregateUseType ) {}
 …
                 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
                         Type * temp = type2;
+                        ValueGuard< Type * > temp( type2 );
                         type2 = enumInstType;
+                        temp->accept( *this );
+                        type2 = temp;
+                        temp.old->accept( *this );
                 } // if
+        }

src/ResolvExpr/ConversionCost.cc

-                      r54cd58b
+                      r9236060
 namespace ResolvExpr {
+        const Cost Cost::zero = Cost( 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1 );
+        const Cost Cost::zero = Cost( 0, 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1, -1 );
+        const Cost Cost::unsafe = Cost( 1, 0, 0, 0 );
+        const Cost Cost::poly = Cost( 0, 1, 0, 0 );
+        const Cost Cost::safe = Cost( 0, 0, 1, 0 );
+        const Cost Cost::reference = Cost( 0, 0, 0, 1 );
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
 …
                                 assert( type );
                                 if ( type->get_base() ) {
                                         return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
+                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
 …
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
 ///     std::cout << "compatible!" << std::endl;
                         return Cost( 0, 0, 0 );
+                        return Cost::zero;
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
+                        return Cost( 0, 0, 1 );
+                        return Cost::safe;
+                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
+                        // std::cerr << "conversionCost: dest is reference" << std::endl;
+                        return convertToReferenceCost( src, refType, indexer, env );
                 } else {
                         ConversionCost converter( dest, indexer, env );
 …
                                 return Cost::infinity;
                         } else {
+                                return converter.get_cost() + Cost( 0, 0, 0 );
+                        } // if
+                } // if
+                                return converter.get_cost() + Cost::zero;
+                        } // if
+                } // if
+        }
+        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                std::cerr << "convert to reference cost..." << std::endl;
+                if ( diff > 0 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff < -1 ) {
+                        // TODO: document this
+                        Cost cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env );
+                        cost.incReference();
+                        return cost;
+                } else if ( diff == 0 ) {
+                        ReferenceType * srcAsRef = dynamic_cast< ReferenceType * >( src );
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
+                                std::cerr << "converting between references" << std::endl;
+                                if ( srcAsRef->get_base()->get_qualifiers() <= destAsRef->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                        return Cost::safe;
+                                } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                                        int assignResult = ptrsAssignable( srcAsRef->get_base(), destAsRef->get_base(), env );
+                                        if ( assignResult < 0 ) {
+                                                return Cost::safe;
+                                        } else if ( assignResult > 0 ) {
+                                                return Cost::unsafe;
+                                        } // if
+                                } // if
+                        } else {
+                                std::cerr << "reference to rvalue conversion" << std::endl;
+                                ConversionCost converter( dest, indexer, env );
+                                src->accept( converter );
+                                return converter.get_cost();
+                        } // if
+                } else {
+                        ReferenceType * destAsRef = dynamic_cast< ReferenceType * >( dest );
+                        assert( diff == -1 && destAsRef );
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                                std::cerr << "converting compatible base type" << std::endl;
+                                if ( src->get_lvalue() ) {
+                                        std::cerr << "lvalue to reference conversion" << std::endl;
+                                        // lvalue-to-reference conversion:  cv lvalue T => cv T &
+                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::reference; // cost needs to be non-zero to add cast
+                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                                return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
+                                        } else {
+                                                return Cost::unsafe;
+                                        } // if
+                                } else if ( destAsRef->get_base()->get_const() ) {
+                                        std::cerr << "rvalue to const ref conversion" << std::endl;
+                                        // rvalue-to-const-reference conversion: T => const T &
+                                        return Cost::safe;
+                                } else {
+                                        // std::cerr << "rvalue to non-const reference conversion" << std::endl;
+                                        // rvalue-to-reference conversion: T => T &
+                                        return Cost::unsafe;
+                                } // if
+                        } // if
+                        std::cerr << "attempting to convert from incompatible base type -- fail" << std::endl;
+                }
+                return Cost::infinity;
+        }
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
+                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env );
+        }
 …
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
                         // xxx - not positive this is correct, but appears to allow casting int => enum
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
+        }
 …
         void ConversionCost::visit(PointerType *pointerType) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
+                        if ( pointerType->get_base()->get_qualifiers() <= destAsPtr->get_base()->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                cost = Cost( 0, 0, 1 );
+                        } else {
+                        // std::cerr << pointerType << " ===> " << destAsPtr;
+                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                                if ( tq1 == tq2 ) {
+                                        // types are the same
+                                        cost = Cost::zero;
+                                } else {
+                                        // types are the same, except otherPointer has more qualifiers
+                                        // std::cerr << " :: compatible and good qualifiers" << std::endl;
+                                        cost = Cost::safe;
+                                }
+                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                 int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
+                                if ( assignResult < 0 ) {
+                                        cost = Cost( 0, 0, 1 );
+                                // std::cerr << " :: " << assignResult << std::endl;
+                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                        cost = Cost::safe;
                                 } else if ( assignResult > 0 ) {
                                         cost = Cost( 1, 0, 0 );
+                                        cost = Cost::unsafe;
                                 } // if
+                                // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
                         cost = Cost( 1, 0, 0 );
+                        cost = Cost::unsafe;
                 } // if
+        }
         void ConversionCost::visit(__attribute((unused)) ArrayType *arrayType) {}
+        void ConversionCost::visit(ReferenceType *refType) {
+                // Note: dest can never be a reference, since it would have been caught in an earlier check
+                assert( ! dynamic_cast< ReferenceType * >( dest ) );
+                // convert reference to rvalue: cv T1 & => T2
+                // recursively compute conversion cost from T1 to T2.
+                // cv can be safely dropped because of 'implicit dereference' behavior.
+                refType->get_base()->accept( *this );
+                if ( refType->get_base()->get_qualifiers() == dest->get_qualifiers() ) {
+                        cost.incReference();  // prefer exact qualifiers
+                } else if ( refType->get_base()->get_qualifiers() < dest->get_qualifiers() ) {
+                        cost.incSafe(); // then gaining qualifiers
+                } else {
+                        cost.incUnsafe(); // lose qualifiers as last resort
+                }
+                // std::cerr << refType << " ==> " << dest << " " << cost << std::endl;
+        }
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 …
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
                 integer.accept( *this );
                 if ( cost < Cost( 1, 0, 0 ) ) {
+                integer.accept( *this );  // safe if dest >= int
+                if ( cost < Cost::unsafe ) {
                         cost.incSafe();
                 } // if
 …
                         assert( type );
                         if ( type->get_base() ) {
                                 cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost( 0, 0, 1 );
+                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
                         } // if
                 } // if
 …
         void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
                 Cost c;
+                Cost c = Cost::zero;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
 …
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
+                        }
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
                         cost = Cost( 0, 0, 1 );
+                        cost = Cost::safe;
+                }
+        }
 …
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
+                                cost = Cost::unsafe;
+                        } else {
+                                cost = Cost::zero;
+                                cost.incSafe( tableResult + 1 );
+                        }
+                }

src/ResolvExpr/ConversionCost.h

-                      r54cd58b
+                      r9236060
 // file "LICENCE" distributed with Cforall.
 //
 // ConversionCost.h --
+// ConversionCost.h --
 //
 // Author           : Richard C. Bilson
 …
           public:
                 ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
                 Cost get_cost() const { return cost; }
 …
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
 …
                 const TypeEnvironment &env;
         };
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env );
 } // namespace ResolvExpr

src/ResolvExpr/Cost.h

-                      r54cd58b
+                      r9236060
 // file "LICENCE" distributed with Cforall.
 //
 // Cost.h --
+// Cost.h --
 //
 // Author           : Richard C. Bilson
 …
 namespace ResolvExpr {
         class Cost {
+          private:
+                Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost );
           public:
+                Cost();
+                Cost( int unsafe, int poly, int safe );
+                void incUnsafe( int inc = 1 );
+                void incPoly( int inc = 1 );
+                void incSafe( int inc = 1 );
+                Cost & incUnsafe( int inc = 1 );
+                Cost & incPoly( int inc = 1 );
+                Cost & incSafe( int inc = 1 );
+                Cost & incReference( int inc = 1 );
                 Cost operator+( const Cost &other ) const;
                 Cost operator-( const Cost &other ) const;
 …
                 bool operator!=( const Cost &other ) const;
                 friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
                 static const Cost zero;
                 static const Cost infinity;
+                static const Cost unsafe;
+                static const Cost poly;
+                static const Cost safe;
+                static const Cost reference;
           private:
                 int compare( const Cost &other ) const;
+                int unsafe;
+                int poly;
+                int safe;
+                int unsafeCost;
+                int polyCost;
+                int safeCost;
+                int referenceCost;
         };
         inline Cost::Cost() : unsafe( 0 ), poly( 0 ), safe( 0 ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {}
         inline Cost::Cost( int unsafe, int poly, int safe ) : unsafe( unsafe ), poly( poly ), safe( safe ) {}
         inline void Cost::incUnsafe( int inc ) {
                 unsafe += inc;
+        inline Cost & Cost::incUnsafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                unsafeCost += inc;
+                return *this;
+        }
+        inline void Cost::incPoly( int inc ) {
+                poly += inc;
+        inline Cost & Cost::incPoly( int inc ) {
+                if ( *this == infinity ) return *this;
+                polyCost += inc;
+                return *this;
+        }
+        inline void Cost::incSafe( int inc ) {
+                safe += inc;
+        inline Cost & Cost::incSafe( int inc ) {
+                if ( *this == infinity ) return *this;
+                safeCost += inc;
+                return *this;
+        }
+        inline Cost & Cost::incReference( int inc ) {
+                if ( *this == infinity ) return *this;
+                referenceCost += inc;
+                return *this;
+        }
         inline Cost Cost::operator+( const Cost &other ) const {
+                return Cost( unsafe + other.unsafe, poly + other.poly, safe + other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost );
+        }
         inline Cost Cost::operator-( const Cost &other ) const {
+                return Cost( unsafe - other.unsafe, poly - other.poly, safe - other.safe );
+                if ( *this == infinity || other == infinity ) return infinity;
+                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost );
+        }
         inline Cost &Cost::operator+=( const Cost &other ) {
+                unsafe += other.unsafe;
+                poly += other.poly;
+                safe += other.safe;
+                if ( *this == infinity ) return *this;
+                if ( other == infinity ) {
+                        *this = infinity;
+                        return *this;
+                }
+                unsafeCost += other.unsafeCost;
+                polyCost += other.polyCost;
+                safeCost += other.safeCost;
+                referenceCost += other.referenceCost;
                 return *this;
+        }
         inline bool Cost::operator<( const Cost &other ) const {
+            if ( *this == infinity ) return false;
+            if ( other == infinity ) return true;
+            if ( unsafe > other.unsafe ) {
+                if ( *this == infinity ) return false;
+                if ( other == infinity ) return true;
+                if ( unsafeCost > other.unsafeCost ) {
                         return false;
             } else if ( unsafe < other.unsafe ) {
+                } else if ( unsafeCost < other.unsafeCost ) {
                         return true;
             } else if ( poly > other.poly ) {
+                } else if ( polyCost > other.polyCost ) {
                         return false;
             } else if ( poly < other.poly ) {
+                } else if ( polyCost < other.polyCost ) {
                         return true;
             } else if ( safe > other.safe ) {
+                } else if ( safeCost > other.safeCost ) {
                         return false;
             } else if ( safe < other.safe ) {
+                } else if ( safeCost < other.safeCost ) {
                         return true;
             } else {
+                } else if ( referenceCost > other.referenceCost ) {
                         return false;
+            } // if
+                } else if ( referenceCost < other.referenceCost ) {
+                        return true;
+                } else {
+                        return false;
+                } // if
+        }
         inline bool Cost::operator==( const Cost &other ) const {
+                return unsafe == other.unsafe
+                        && poly == other.poly
+                        && safe == other.safe;
+                return unsafeCost == other.unsafeCost
+                        && polyCost == other.polyCost
+                        && safeCost == other.safeCost
+                        && referenceCost == other.referenceCost;
+        }
 …
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
                 os << "( " << cost.unsafe << ", " << cost.poly << ", " << cost.safe << " )";
+                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )";
                 return os;
+        }

src/ResolvExpr/Unify.cc

-                      r54cd58b
+                      r9236060
                 virtual void visit(PointerType *pointerType);
                 virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
                 virtual void visit(FunctionType *functionType);
                 virtual void visit(StructInstType *aggregateUseType);
 …
                                 } // if
                         } else {
+                                common = type1->clone();
+                                common->get_qualifiers() = tq1 | tq2;
                                 result = true;
                         } // if
 …
                         markAssertions( haveAssertions, needAssertions, pointerType );
                         markAssertions( haveAssertions, needAssertions, otherPointer );
+                } // if
+        }
+        void Unify::visit(ReferenceType *refType) {
+                if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
+                        result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
+                        markAssertions( haveAssertions, needAssertions, refType );
+                        markAssertions( haveAssertions, needAssertions, otherRef );
                 } // if
+        }

src/ResolvExpr/typeops.h

-                      r54cd58b
+                      r9236060
         Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        template< typename SrcIterator, typename DestIterator >
-        Cost castCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                Cost ret;
-                if ( destBegin == destEnd ) {
-                        if ( srcBegin == srcEnd ) {
-                                return Cost::zero;
-                        } else {
-                                return Cost( 0, 0, 1 );
-                        } // if
-                } // if
-                while ( srcBegin != srcEnd && destBegin != destEnd ) {
-                        Cost thisCost = castCost( *srcBegin++, *destBegin++, indexer, env );
-                        if ( thisCost == Cost::infinity ) {
-                                return Cost::infinity;
-                        } // if
-                        ret += thisCost;
-                } // while
-                if ( srcBegin == srcEnd && destBegin == destEnd ) {
-                        return ret;
-                } else {
-                        return Cost::infinity;
-                } // if
+        }
         // in ConversionCost.cc
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
-        template< typename SrcIterator, typename DestIterator >
-        Cost conversionCostList( SrcIterator srcBegin, SrcIterator srcEnd, DestIterator destBegin, DestIterator destEnd, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
-                Cost ret;
-                while ( srcBegin != srcEnd && destBegin != destEnd ) {
-                        Cost thisCost = conversionCost( *srcBegin++, *destBegin++, indexer, env );
-                        if ( thisCost == Cost::infinity ) {
-                                return Cost::infinity;
-                        } // if
-                        ret += thisCost;
-                } // while
-                if ( srcBegin == srcEnd && destBegin == destEnd ) {
-                        return ret;
-                } else {
-                        return Cost::infinity;
-                } // if
+        }
         // in PtrsAssignable.cc

src/SymTab/Autogen.cc

-                      r54cd58b
+                      r9236060
 // Update Count     : 62
 //
 #include "Autogen.h"
 …
 #include "AddVisit.h"              // for addVisit
+#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
 …
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
 #include "SymTab/Mangler.h"        // for Mangler
+#include "SynTree/Attribute.h"     // For Attribute
 #include "SynTree/Mutator.h"       // for maybeMutate
 #include "SynTree/Statement.h"     // for CompoundStmt, ReturnStmt, ExprStmt
 …
         FunctionType * genDefaultType( Type * paramType ) {
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new PointerType( Type::Qualifiers(), paramType->clone() ), nullptr );
+                ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->get_parameters().push_back( dstParam );
 …
                         FunctionType * ftype = funcDecl->get_functionType();
                         assert( ! ftype->get_parameters().empty() );
+                        Type * t = safe_dynamic_cast< PointerType * >( ftype->get_parameters().front()->get_type() )->get_base();
+                        Type * t = InitTweak::getPointerBase( ftype->get_parameters().front()->get_type() );
+                        assert( t );
                         map.insert( Mangler::mangleType( t ), true );
+                }
 …
                         FunctionType * ftype = data.genType( refType );
                         if(concurrent_type && InitTweak::isDestructor( data.fname )) {
+                        if(concurrent_type && CodeGen::isDestructor( data.fname )) {
                                 ftype->get_parameters().front()->get_type()->set_mutex( true );
+                        }
 …
                 FunctionType *copyCtorType = genCopyType( refType->clone() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
                 // xxx - should we also generate void ?{}(E *, int) and E ?{}(E *, E)?
                 // right now these cases work, but that might change.
 …
         /// generates a single struct member operation (constructor call, destructor call, assignment call)
         void makeStructMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool isDynamicLayout, bool forward = true ) {
-                ObjectDecl * returnVal = NULL;
-                if ( ! func->get_functionType()->get_returnVals().empty() ) {
-                        returnVal = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_returnVals().front() );
+                }
                 InitTweak::InitExpander srcParam( src );
+                // assign to destination (and return value if generic)
+                UntypedExpr *derefExpr = UntypedExpr::createDeref( new VariableExpr( dstParam ) );
+                Expression *dstselect = new MemberExpr( field, derefExpr );
+                // assign to destination
+                Expression *dstselect = new MemberExpr( field, new CastExpr( new VariableExpr( dstParam ), safe_dynamic_cast< ReferenceType* >( dstParam->get_type() )->get_base()->clone() ) );
                 genImplicitCall( srcParam, dstselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
-                if ( isDynamicLayout && returnVal ) {
-                        // xxx - there used to be a dereference on returnVal, but this seems to have been wrong?
-                        Expression *retselect = new MemberExpr( field, new VariableExpr( returnVal ) );
-                        genImplicitCall( srcParam, retselect, func->get_name(), back_inserter( func->get_statements()->get_kids() ), field, forward );
-                } // if
+        }
 …
                 // field ctors are only generated if default constructor and copy constructor are both generated
                 unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return InitTweak::isConstructor( dcl->get_name() ); } );
+                unsigned numCtors = std::count_if( newFuncs.begin(), newFuncs.end(), [](FunctionDecl * dcl) { return CodeGen::isConstructor( dcl->get_name() ); } );
                 if ( functionNesting == 0 ) {
 …
                         // generate appropriate calls to member ctor, assignment
                         // destructor needs to do everything in reverse, so pass "forward" based on whether the function is a destructor
                         if ( ! InitTweak::isDestructor( dcl->get_name() ) ) {
+                        if ( ! CodeGen::isDestructor( dcl->get_name() ) ) {
                                 makeStructFunctionBody( aggregateDecl->get_members().begin(), aggregateDecl->get_members().end(), dcl, isDynamicLayout );
                         } else {
                                 makeStructFunctionBody( aggregateDecl->get_members().rbegin(), aggregateDecl->get_members().rend(), dcl, isDynamicLayout, false );
+                        }
                         if ( InitTweak::isAssignment( dcl->get_name() ) ) {
+                        if ( CodeGen::isAssignment( dcl->get_name() ) ) {
                                 // assignment needs to return a value
                                 FunctionType * assignType = dcl->get_functionType();
 …
                                         // our inheritance model. I think the correct way to handle this is to
                                         // cast the structure to the type of the member and let the resolver
+                                        // figure out whether it's valid and have a pass afterwards that fixes
+                                        // the assignment to use pointer arithmetic with the offset of the
+                                        // member, much like how generic type members are handled.
+                                        // figure out whether it's valid/choose the correct unnamed member
                                         continue;
+                                }
 …
         void makeUnionFieldsAssignment( ObjectDecl * srcParam, ObjectDecl * dstParam, OutputIterator out ) {
                 UntypedExpr *copy = new UntypedExpr( new NameExpr( "__builtin_memcpy" ) );
                 copy->get_args().push_back( new VariableExpr( dstParam ) );
+                copy->get_args().push_back( new AddressExpr( new VariableExpr( dstParam ) ) );
                 copy->get_args().push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
                 copy->get_args().push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
 …
                 ObjectDecl * dstParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().front() );
                 ObjectDecl * srcParam = safe_dynamic_cast< ObjectDecl * >( ftype->get_parameters().back() );
-                ObjectDecl * returnVal = nullptr;
-                if ( ! ftype->get_returnVals().empty() ) {
-                        returnVal = safe_dynamic_cast< ObjectDecl * >( ftype->get_returnVals().front() );
+                }
                 makeUnionFieldsAssignment( srcParam, dstParam, back_inserter( funcDecl->get_statements()->get_kids() ) );
+                if ( returnVal ) {
+                if ( CodeGen::isAssignment( funcDecl->get_name() ) ) {
+                        // also generate return statement in assignment
                         funcDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new VariableExpr( srcParam ) ) );
+                }
 …
                 cloneAll( typeParams, copyCtorType->get_forall() );
                 cloneAll( typeParams, assignType->get_forall() );
+                // add unused attribute to parameters of default constructor and destructor
+                ctorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
+                dtorType->get_parameters().front()->get_attributes().push_back( new Attribute( "unused" ) );
                 // Routines at global scope marked "static" to prevent multiple definitions is separate translation units

src/SymTab/Autogen.h

-                      r54cd58b
+                      r9236060
         extern Type * SizeType;
+        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
+        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
+        extern FunctionDecl * dereferenceOperator;
+        // temporary
+        FunctionType * genAssignType( Type * paramType );
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
 …
         template< typename OutputIterator >
         Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false ) {
         // want to be able to generate assignment, ctor, and dtor generically,
         // so fname is either ?=?, ?{}, or ^?{}
         UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+                // want to be able to generate assignment, ctor, and dtor generically,
+                // so fname is either ?=?, ?{}, or ^?{}
+                UntypedExpr *fExpr = new UntypedExpr( new NameExpr( fname ) );
+        // do something special for unnamed members
+        dstParam = new AddressExpr( dstParam );
+        if ( addCast ) {
+                // cast to T* with qualifiers removed, so that qualified objects can be constructed
+                // and destructed with the same functions as non-qualified objects.
+                // 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();
+                assert( type );
+                Type * castType = type->clone();
+                castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                castType->set_lvalue( true ); // xxx - might not need this
+                dstParam = new CastExpr( dstParam, new PointerType( Type::Qualifiers(), castType ) );
+        }
+        fExpr->get_args().push_back( dstParam );
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed
+                        // and destructed with the same functions as non-qualified objects.
+                        // 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();
+                        assert( type );
+                        Type * castType = type->clone();
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        // castType->set_lvalue( true ); // xxx - might not need this
+                        dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
+                }
+                fExpr->get_args().push_back( dstParam );
         Statement * listInit = srcParam.buildListInit( fExpr );
+                Statement * listInit = srcParam.buildListInit( fExpr );
         std::list< Expression * > args = *++srcParam;
         fExpr->get_args().splice( fExpr->get_args().end(), args );
+                std::list< Expression * > args = *++srcParam;
+                fExpr->get_args().splice( fExpr->get_args().end(), args );
         *out++ = new ExprStmt( noLabels, fExpr );
+                *out++ = new ExprStmt( noLabels, fExpr );
         srcParam.clearArrayIndices();
+                srcParam.clearArrayIndices();
         return listInit;
+                return listInit;
+        }
 …
                 UntypedExpr *inc = new UntypedExpr( update );
                 inc->get_args().push_back( new AddressExpr( new VariableExpr( index ) ) );
+                inc->get_args().push_back( new VariableExpr( index ) );
                 UntypedExpr *dstIndex = new UntypedExpr( new NameExpr( "?[?]" ) );

src/SymTab/Indexer.cc

-                      r54cd58b
+                      r9236060
 #include <utility>                 // for pair, make_pair, move
+#include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
 …
         void Indexer::removeSpecialOverrides( const std::string &id, std::list< DeclarationWithType * > & out ) const {
                 // only need to perform this step for constructors, destructors, and assignment functions
                 if ( ! InitTweak::isCtorDtorAssign( id ) ) return;
+                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
                 // helpful data structure
 …
                                 decls.push_back( DeclBall{ function, isUserDefinedFunc, isDefaultCtor, isDtor, isCopyFunc } );
                                 existsUserDefinedFunc = existsUserDefinedFunc || isUserDefinedFunc;
                                 existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && InitTweak::isConstructor( function->get_name() ) );
+                                existsUserDefinedCtor = existsUserDefinedCtor || (isUserDefinedFunc && CodeGen::isConstructor( function->get_name() ) );
                                 existsUserDefinedDtor = existsUserDefinedDtor || (isUserDefinedFunc && isDtor);
                                 existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
 …
                                 assert( ! params.empty() );
                                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                                Type * base = safe_dynamic_cast< PointerType * >( params.front()->get_type() )->get_base();
+                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                                assert( base );
                                 funcMap[ Mangler::mangle( base ) ] += function;
                         } else {

src/SymTab/Mangler.cc

-                      r54cd58b
+                      r9236060
                 mangleName << "A0";
                 maybeAccept( arrayType->get_base(), *this );
+        }
+        void Mangler::visit( ReferenceType *refType ) {
+                printQualifiers( refType );
+                mangleName << "R";
+                maybeAccept( refType->get_base(), *this );
+        }
 …
                 // Removed due to restrict not affecting function compatibility in GCC
 //              if ( type->get_isRestrict() ) {
 //                      mangleName << "R";
+//                      mangleName << "E";
 //              } // if
                 if ( type->get_lvalue() ) {

src/SymTab/Mangler.h

r54cd58b	r9236060
42	42	virtual void visit( PointerType *pointerType );
43	43	virtual void visit( ArrayType *arrayType );
	44	virtual void visit( ReferenceType *refType );
44	45	virtual void visit( FunctionType *functionType );
45	46	virtual void visit( StructInstType *aggregateUseType );

src/SymTab/Validate.cc

-                      r54cd58b
+                      r9236060
 #include "Autogen.h"                   // for SizeType, autogenerateRoutines
 #include "CodeGen/CodeGenerator.h"     // for genName
+#include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap<>::const_iterator
 …
         };
+        FunctionDecl * dereferenceOperator = nullptr;
+        struct FindSpecialDeclarations final {
+                void previsit( FunctionDecl * funcDecl );
+        };
         void validate( std::list< Declaration * > &translationUnit, bool doDebug ) {
                 PassVisitor<EnumAndPointerDecay> epc;
 …
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
+                PassVisitor<FindSpecialDeclarations> finder;
                 EliminateTypedef::eliminateTypedef( translationUnit );
 …
                 acceptAll( translationUnit, fpd );
                 ArrayLength::computeLength( translationUnit );
+                acceptAll( translationUnit, finder );
+        }
 …
                 std::list< DeclarationWithType * > &params = funcType->get_parameters();
                 if ( InitTweak::isCtorDtorAssign( funcDecl->get_name() ) ) {
+                if ( CodeGen::isCtorDtorAssign( funcDecl->get_name() ) ) { // TODO: also check /=, etc.
                         if ( params.size() == 0 ) {
                                 throw SemanticError( "Constructors, destructors, and assignment functions require at least one parameter ", funcDecl );
+                        }
                         PointerType * ptrType = dynamic_cast< PointerType * >( params.front()->get_type() );
                         if ( ! ptrType || ptrType->is_array() ) {
                                 throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a pointer ", funcDecl );
+                        ReferenceType * refType = dynamic_cast< ReferenceType * >( params.front()->get_type() );
+                        if ( ! refType ) {
+                                throw SemanticError( "First parameter of a constructor, destructor, or assignment function must be a reference ", funcDecl );
+                        }
                         if ( InitTweak::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
+                        if ( CodeGen::isCtorDtor( funcDecl->get_name() ) && returnVals.size() != 0 ) {
                                 throw SemanticError( "Constructors and destructors cannot have explicit return values ", funcDecl );
+                        }
 …
+                }
+        }
+        void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) {
+                if ( ! dereferenceOperator ) {
+                        if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) {
+                                FunctionType * ftype = funcDecl->get_functionType();
+                                if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) {
+                                        dereferenceOperator = funcDecl;
+                                }
+                        }
+                }
+        }
 } // namespace SymTab

src/SynTree/AddressExpr.cc

-                      r54cd58b
+                      r9236060
 #include "Common/utility.h"
+// Address expressions are typed based on the following inference rules:
+//    E : lvalue T  &..& (n references)
+//   &E :        T *&..& (n references)
+//
+//    E : T  &..&        (m references)
+//   &E : T *&..&        (m-1 references)
+//
+// That is, lvalues becomes
+namespace {
+        Type * addrType( Type * type ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( type ) ) {
+                        return new ReferenceType( refType->get_qualifiers(), addrType( refType->get_base() ) );
+                } else {
+                        return new PointerType( Type::Qualifiers(), type->clone() );
+                }
+        }
+}
 AddressExpr::AddressExpr( Expression *arg, Expression *_aname ) : Expression( _aname ), arg( arg ) {
         if ( arg->has_result() ) {
+                set_result( new PointerType( Type::Qualifiers(), arg->get_result()->clone() ) );
+                if ( arg->get_result()->get_lvalue() ) {
+                        // lvalue, retains all layers of reference and gains a pointer inside the references
+                        set_result( addrType( arg->get_result() ) );
+                } else {
+                        // taking address of non-lvalue -- must be a reference, loses one layer of reference
+                        ReferenceType * refType = safe_dynamic_cast< ReferenceType * >( arg->get_result() );
+                        set_result( addrType( refType->get_base() ) );
+                }
+                // result of & is never an lvalue
+                get_result()->set_lvalue( false );
+        }
+}

src/SynTree/ApplicationExpr.cc

r54cd58b	r9236060
44	44	}
45	45
46		ApplicationExpr::ApplicationExpr( Expression funcExpr, const std::list< ~~Expression > & argList ) : function( funcExpr ), args( argList~~ ) {
	46	ApplicationExpr::ApplicationExpr( Expression funcExpr, const std::list<Expression > & args ) : function( funcExpr ), args( args ) {
47	47	PointerType pointer = safe_dynamic_cast< PointerType >( funcExpr->get_result() );
48	48	FunctionType function = safe_dynamic_cast< FunctionType >( pointer->get_base() );

src/SynTree/Expression.cc

-                      r54cd58b
+                      r9236060
 #include "InitTweak/InitTweak.h"
+#include "GenPoly/Lvalue.h"
 Expression::Expression( Expression *_aname ) : result( 0 ), env( 0 ), argName( _aname ) {}
 …
+}
+VariableExpr * VariableExpr::functionPointer( FunctionDecl * func ) {
+        VariableExpr * funcExpr = new VariableExpr( func );
+        funcExpr->set_result( new PointerType( Type::Qualifiers(), funcExpr->get_result() ) );
+        return funcExpr;
+}
 void VariableExpr::print( std::ostream &os, int indent ) const {
         os << "Variable Expression: ";
 …
 void AlignofExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Alignof Expression on: ";
+        os << "Alignof Expression on: ";
         if (isType)
 …
 void AttrExpr::print( std::ostream &os, int indent) const {
         os << std::string( indent, ' ' ) << "Attr ";
+        os << "Attr ";
         attr->print( os, indent + 2 );
         if ( isType || expr ) {
 …
 namespace {
         TypeSubstitution makeSub( Type * t ) {
+                if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
+                if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( t ) ) {
+                        return makeSub( refType->get_base() );
+                } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
                         return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
 …
         if ( Type * type = expr->get_result() ) {
                 Type * base = InitTweak::getPointerBase( type );
+                if ( ! base ) {
+                        std::cerr << type << std::endl;
+                assertf( base, "expected pointer type in dereference (type was %s)", toString( type ).c_str() );
+                ret->set_result( base->clone() );
+                if ( GenPoly::referencesPermissable() ) {
+                        // if references are still allowed in the AST, dereference returns a reference
+                        ret->set_result( new ReferenceType( Type::Qualifiers(), ret->get_result() ) );
+                } else {
+                        // references have been removed, in which case dereference returns an lvalue of the base type.
+                        ret->get_result()->set_lvalue( true );
+                }
-                assertf( base, "expected pointer type in dereference\n" );
-                ret->set_result( maybeClone( base ) );
+        }
         return ret;
 …
 void LogicalExpr::print( std::ostream &os, int indent )const {
         os << std::string( indent, ' ' ) << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
+        os << "Short-circuited operation (" << (isAnd?"and":"or") << ") on: ";
         arg1->print(os);
         os << " and ";

src/SynTree/Expression.h

r54cd58b	r9236060
280	280	void set_var( DeclarationWithType * newValue ) { var = newValue; }
281	281
	282	static VariableExpr * functionPointer( FunctionDecl * decl );
	283
282	284	virtual VariableExpr * clone() const { return new VariableExpr( * this ); }
283	285	virtual void accept( Visitor & v ) { v.visit( this ); }

src/SynTree/Mutator.cc

-                      r54cd58b
+                      r9236060
+}
+Type *Mutator::mutate( ReferenceType *refType ) {
+        mutateAll( refType->get_forall(), *this );
+        refType->set_base( maybeMutate( refType->get_base(), *this ) );
+        return refType;
+}
 Type *Mutator::mutate( FunctionType *functionType ) {
         mutateAll( functionType->get_forall(), *this );

src/SynTree/Mutator.h

r54cd58b	r9236060
92	92	virtual Type* mutate( PointerType *pointerType );
93	93	virtual Type* mutate( ArrayType *arrayType );
	94	virtual Type* mutate( ReferenceType *refType );
94	95	virtual Type* mutate( FunctionType *functionType );
95	96	virtual Type* mutate( StructInstType *aggregateUseType );

src/SynTree/SynTree.h

r54cd58b	r9236060
101	101	class PointerType;
102	102	class ArrayType;
	103	class ReferenceType;
103	104	class FunctionType;
104	105	class ReferenceToType;

src/SynTree/Type.cc

-                      r54cd58b
+                      r9236060
 const char * Type::QualifiersNames[] = { "const", "restrict", "volatile", "lvalue", "mutex", "_Atomic" };
 Type *Type::stripDeclarator() {
+Type * Type::stripDeclarator() {
         Type * type = this;
         while ( Type * at = InitTweak::getPointerBase( type ) ) {
 …
         return type;
+}
+Type * Type::stripReferences() {
+        Type * type = this;
+        while ( ReferenceType * ref = dynamic_cast<ReferenceType *>( type ) ) {
+                type = ref->get_base();
+        }
+        return type;
+}
+int Type::referenceDepth() const { return 0; }
 void Type::print( std::ostream &os, int indent ) const {

src/SynTree/Type.h

-                      r54cd58b
+                      r9236060
         /// return type without outer pointers and arrays
+        Type *stripDeclarator();
+        Type * stripDeclarator();
+        /// return type without outer references
+        Type * stripReferences();
+        /// return the number of references occuring consecutively on the outermost layer of this type (i.e. do not count references nested within other types)
+        virtual int referenceDepth() const;
         virtual bool isComplete() const { return true; }
 …
         bool is_array() const { return isStatic || isVarLen || dimension; }
+        virtual bool isComplete() const { return ! isVarLen; }
         virtual PointerType *clone() const { return new PointerType( *this ); }
         virtual void accept( Visitor & v ) { v.visit( this ); }
 …
 };
+class ReferenceType : public Type {
+public:
+        Type *base;
+        ReferenceType( const Type::Qualifiers & tq, Type *base, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        ReferenceType( const ReferenceType & );
+        virtual ~ReferenceType();
+        Type *get_base() { return base; }
+        void set_base( Type *newValue ) { base = newValue; }
+        virtual int referenceDepth() const;
+        virtual ReferenceType *clone() const { return new ReferenceType( *this ); }
+        virtual void accept( Visitor & v ) { v.visit( this ); }
+        virtual Type *acceptMutator( Mutator & m ) { return m.mutate( this ); }
+        virtual void print( std::ostream & os, int indent = 0 ) const;
+};
 class FunctionType : public Type {
   public:

src/SynTree/TypeExpr.cc

r54cd58b	r9236060
5	5	// file "LICENCE" distributed with Cforall.
6	6	//
7		// TypeExpr.cc --
	7	// TypeExpr.cc --
8	8	//
9	9	// Author : Richard C. Bilson

src/SynTree/Visitor.cc

-                      r54cd58b
+                      r9236060
 void Visitor::visit( PointerType *pointerType ) {
         acceptAll( pointerType->get_forall(), *this );
+        // xxx - should PointerType visit/mutate dimension?
         maybeAccept( pointerType->get_base(), *this );
+}
 …
         maybeAccept( arrayType->get_dimension(), *this );
         maybeAccept( arrayType->get_base(), *this );
+}
+void Visitor::visit( ReferenceType *refType ) {
+        acceptAll( refType->get_forall(), *this );
+        maybeAccept( refType->get_base(), *this );
+}

src/SynTree/Visitor.h

r54cd58b	r9236060
95	95	virtual void visit( PointerType *pointerType );
96	96	virtual void visit( ArrayType *arrayType );
	97	virtual void visit( ReferenceType *refType );
97	98	virtual void visit( FunctionType *functionType );
98	99	virtual void visit( StructInstType *aggregateUseType );

src/SynTree/module.mk

r54cd58b	r9236060
20	20	SynTree/PointerType.cc \
21	21	SynTree/ArrayType.cc \
	22	SynTree/ReferenceType.cc \
22	23	SynTree/FunctionType.cc \
23	24	SynTree/ReferenceToType.cc \

src/Tuples/Explode.h

-                      r54cd58b
+                      r9236060
 namespace Tuples {
-        /// helper function used by explode to properly distribute
-        /// '&' across a tuple expression
-        Expression * distributeAddr( Expression * expr );
         /// helper function used by explode
         template< typename OutputIterator >
         void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
+                if ( isTupleAssign ) {
+                        // tuple assignment needs AddressExprs to be recursively exploded to easily get at all of the components
+                        if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
+                                ResolvExpr::AltList alts;
+                                explodeUnique( addrExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                for ( ResolvExpr::Alternative & alt : alts ) {
+                                        // distribute '&' over all components
+                                        alt.expr = distributeAddr( alt.expr );
+                                        *out++ = alt;
+                                }
+                                // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
+                                return;
+                        }
+                }
+                Type * res = expr->get_result();
+                Type * res = expr->get_result()->stripReferences();
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( res ) ) {
                         if ( TupleExpr * tupleExpr = dynamic_cast< TupleExpr * >( expr ) ) {
 …
+                                }
                         } else {
+                                // tuple type, but not tuple expr - recursively index into its components
+                                // tuple type, but not tuple expr - recursively index into its components.
+                                // if expr type is reference, convert to value type
                                 Expression * arg = expr->clone();
+                                if ( dynamic_cast<ReferenceType *>( arg->get_result() ) ) {
+                                        // TODO: does this go here (inside uniqueexpr) or outside uniqueexpr? I'm guessing probably should go after...
+                                        arg = new CastExpr( arg, tupleType->clone() );
+                                }
                                 if ( Tuples::maybeImpure( arg ) && ! dynamic_cast< UniqueExpr * >( arg ) ) {
                                         // expressions which may contain side effects require a single unique instance of the expression.

src/Tuples/TupleAssignment.cc

-                      r54cd58b
+                      r9236060
 #include "Explode.h"
 #include "Common/SemanticError.h"
+#include "CodeGen/OperatorTable.h"
 #include "InitTweak/InitTweak.h"
 #include "InitTweak/GenInit.h"
 …
                 if ( ! expr ) return false;
                 assert( expr->has_result() );
                 return dynamic_cast< TupleType * >( expr->get_result() );
+                return dynamic_cast< TupleType * >( expr->get_result()->stripReferences() );
+        }
 …
+        }
+        bool pointsToTuple( Expression *expr ) {
+        bool refToTuple( Expression *expr ) {
+                assert( expr->get_result() );
                 // also check for function returning tuple of reference types
                 if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
                         return pointsToTuple( castExpr->get_arg() );
                 } else if ( AddressExpr *addr = dynamic_cast< AddressExpr * >( expr) ) {
                         return isTuple( addr->get_arg() );
+                        return refToTuple( castExpr->get_arg() );
+                } else {
+                        return isTuple( expr );
+                }
                 return false;
 …
         void TupleAssignSpotter::spot( UntypedExpr * expr, const std::list<ResolvExpr::AltList> &possibilities ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
                         if ( InitTweak::isCtorDtorAssign( op->get_name() ) ) {
+                        if ( CodeGen::isCtorDtorAssign( op->get_name() ) ) {
                                 fname = op->get_name();
                                 for ( std::list<ResolvExpr::AltList>::const_iterator ali = possibilities.begin(); ali != possibilities.end(); ++ali ) {
                                         if ( ali->size() == 0 ) continue; // AlternativeFinder will natrually handle this case, if it's legal
                                         if ( ali->size() <= 1 && InitTweak::isAssignment( op->get_name() ) ) {
+                                        if ( ali->size() <= 1 && CodeGen::isAssignment( op->get_name() ) ) {
                                                 // what does it mean if an assignment takes 1 argument? maybe someone defined such a function, in which case AlternativeFinder will naturally handle it
                                                 continue;
 …
                                         const ResolvExpr::Alternative & alt1 = ali->front();
                                         auto begin = std::next(ali->begin(), 1), end = ali->end();
                                         if ( pointsToTuple(alt1.expr) ) {
+                                        if ( refToTuple(alt1.expr) ) {
                                                 if ( isMultAssign( begin, end ) ) {
                                                         matcher.reset( new MultipleAssignMatcher( *this, *ali ) );
 …
                         for ( ResolvExpr::Alternative & alt : lhs ) {
                                 Expression *& expr = alt.expr;
+                                Type * castType = expr->get_result()->clone();
+                                Type * type = InitTweak::getPointerBase( castType );
+                                assert( type );
+                                Type * type = expr->get_result()->clone();
                                 type->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                                type->set_lvalue( true ); // xxx - might not need this
+                                expr = new CastExpr( expr, castType );
+                                expr = new CastExpr( expr, new ReferenceType( Type::Qualifiers(), type ) );
+                        }
+                }
+                for ( ResolvExpr::Alternative & alt : lhs ) {
+                        // every LHS value must be a reference - some come in with a cast expression, if it doesn't just cast to reference here.
+                        // TODO: can this somehow be merge with the cast code directly above?
+                        if ( ! dynamic_cast< ReferenceType * >( alt.expr->get_result() ) ) {
+                                alt.expr = new CastExpr( alt.expr, new ReferenceType( Type::Qualifiers(), alt.expr->get_result()->clone() ) );
+                        }
+                }
 …
                 assert( left );
                 std::list< Expression * > args;
                 args.push_back( new AddressExpr( UntypedExpr::createDeref( new VariableExpr( left ) ) ) );
+                args.push_back( new VariableExpr( left ) );
                 // args.push_back( new AddressExpr( new VariableExpr( left ) ) );
                 if ( right ) args.push_back( new VariableExpr( right ) );
 …
                 assert( expr->has_result() && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->get_result()->clone(), new SingleInit( expr->clone() ) );
+                ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                ret->set_init( ctorInit );
+                ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                ctorInit->accept( rm );
+                // if expression type is a reference, don't need to construct anything, a simple initializer is sufficient.
+                if ( ! dynamic_cast< ReferenceType * >( expr->get_result() ) ) {
+                        ConstructorInit * ctorInit = InitTweak::genCtorInit( ret );
+                        ret->set_init( ctorInit );
+                        ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
+                        EnvRemover rm; // remove environments from subexpressions of StmtExprs
+                        ctorInit->accept( rm );
+                }
                 return ret;
+        }

src/libcfa/concurrency/alarm.c

-                      r54cd58b
+                      r9236060
 __cfa_time_t zero_time = { 0 };
 void ?{}( __cfa_time_t * this ) { this->val = 0; }
 void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
 void ?{}( itimerval * this, __cfa_time_t * alarm ) {
         this->it_value.tv_sec = alarm->val / one_second;                        // seconds
         this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
         this->it_interval.tv_sec = 0;
         this->it_interval.tv_usec = 0;
+}
 void ?{}( __cfa_time_t * this, timespec * curr ) {
+void ?{}( __cfa_time_t & this ) { this.val = 0; }
+void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; }
+void ?{}( itimerval & this, __cfa_time_t * alarm ) {
+        this.it_value.tv_sec = alarm->val / one_second;                 // seconds
+        this.it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+        this.it_interval.tv_sec = 0;
+        this.it_interval.tv_usec = 0;
+}
+void ?{}( __cfa_time_t & this, timespec * curr ) {
         uint64_t secs  = curr->tv_sec;
         uint64_t nsecs = curr->tv_nsec;
         this->val = (secs * one_second) + nsecs;
+}
 __cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
         this->val = 0;
         return *this;
+        this.val = (secs * one_second) + nsecs;
+}
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) {
+        this.val = 0;
+        return this;
+}
 …
 //=============================================================================================
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->thrd = thrd;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
         this->set = false;
         this->kernel_alarm = false;
+}
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->proc = proc;
         this->alarm = alarm;
         this->period = period;
         this->next = 0;
         this->set = false;
         this->kernel_alarm = true;
+}
 void ^?{}( alarm_node_t * this ) {
         if( this->set ) {
                 unregister_self( this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.thrd = thrd;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = false;
+}
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+        this.proc = proc;
+        this.alarm = alarm;
+        this.period = period;
+        this.next = 0;
+        this.set = false;
+        this.kernel_alarm = true;
+}
+void ^?{}( alarm_node_t & this ) {
+        if( this.set ) {
+                unregister_self( &this );
+        }
+}

src/libcfa/concurrency/alarm.h

-                      r54cd58b
+                      r9236060
 // ctors
 void ?{}( __cfa_time_t * this );
 void ?{}( __cfa_time_t * this, zero_t zero );
 void ?{}( __cfa_time_t * this, timespec * curr );
 void ?{}( itimerval * this, __cfa_time_t * alarm );
+void ?{}( __cfa_time_t & this );
+void ?{}( __cfa_time_t & this, zero_t zero );
+void ?{}( __cfa_time_t & this, timespec * curr );
+void ?{}( itimerval & this, __cfa_time_t * alarm );
 __cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs );
+__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs );
 // logical ops
 …
 typedef alarm_node_t ** __alarm_it_t;
 void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
 void ^?{}( alarm_node_t * this );
+void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time );
+void ^?{}( alarm_node_t & this );
 struct alarm_list_t {
 …
 };
 static inline void ?{}( alarm_list_t * this ) {
         this->head = 0;
         this->tail = &this->head;
+static inline void ?{}( alarm_list_t & this ) {
+        this.head = 0;
+        this.tail = &this.head;
+}

src/libcfa/concurrency/coroutine

-                      r54cd58b
+                      r9236060
 // Anything that is resumed is a coroutine.
 trait is_coroutine(dtype T) {
       void main(T * this);
       coroutine_desc * get_coroutine(T * this);
+      void main(T & this);
+      coroutine_desc * get_coroutine(T & this);
 };
 #define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X* this) { return &this->__cor; } void main(X* this)
+#define DECL_COROUTINE(X) static inline coroutine_desc* get_coroutine(X& this) { return &this.__cor; } void main(X& this)
 //-----------------------------------------------------------------------------
 // Ctors and dtors
 void ?{}(coStack_t * this);
 void ?{}(coroutine_desc * this);
 void ?{}(coroutine_desc * this, const char * name);
 void ^?{}(coStack_t * this);
 void ^?{}(coroutine_desc * this);
+void ?{}(coStack_t & this);
+void ?{}(coroutine_desc & this);
+void ?{}(coroutine_desc & this, const char * name);
+void ^?{}(coStack_t & this);
+void ^?{}(coroutine_desc & this);
 //-----------------------------------------------------------------------------
 …
 forall(dtype T | is_coroutine(T))
 static inline void resume(T * cor);
+static inline void resume(T & cor);
 forall(dtype T | is_coroutine(T))
 void prime(T * cor);
+void prime(T & cor);
 //-----------------------------------------------------------------------------
 …
 // Resume implementation inlined for performance
 forall(dtype T | is_coroutine(T))
 static inline void resume(T * cor) {
+static inline void resume(T & cor) {
         coroutine_desc * src = this_coroutine;          // optimization
         coroutine_desc * dst = get_coroutine(cor);
 …
         if( unlikely(!dst->stack.base) ) {
                 create_stack(&dst->stack, dst->stack.size);
                 CtxStart(cor, CtxInvokeCoroutine);
+                CtxStart(&cor, CtxInvokeCoroutine);
+        }

src/libcfa/concurrency/coroutine.c

-                      r54cd58b
+                      r9236060
 //-----------------------------------------------------------------------------
 // Coroutine ctors and dtors
 void ?{}(coStack_t* this) {
         this->size              = 65000;        // size of stack
         this->storage   = NULL; // pointer to stack
         this->limit             = NULL; // stack grows towards stack limit
         this->base              = NULL; // base of stack
         this->context   = NULL; // address of cfa_context_t
         this->top               = NULL; // address of top of storage
         this->userStack = false;
+void ?{}(coStack_t& this) {
+        this.size               = 65000;        // size of stack
+        this.storage    = NULL; // pointer to stack
+        this.limit              = NULL; // stack grows towards stack limit
+        this.base               = NULL; // base of stack
+        this.context    = NULL; // address of cfa_context_t
+        this.top                = NULL; // address of top of storage
+        this.userStack  = false;
+}
 void ?{}(coStack_t* this, size_t size) {
+void ?{}(coStack_t& this, size_t size) {
         this{};
         this->size = size;
+        this.size = size;
         create_stack(this, this->size);
+        create_stack(&this, this.size);
+}
 void ?{}(coroutine_desc* this) {
+void ?{}(coroutine_desc& this) {
         this{ "Anonymous Coroutine" };
+}
 void ?{}(coroutine_desc* this, const char * name) {
         this->name = name;
         this->errno_ = 0;
         this->state = Start;
         this->starter = NULL;
         this->last = NULL;
+void ?{}(coroutine_desc& this, const char * name) {
+        this.name = name;
+        this.errno_ = 0;
+        this.state = Start;
+        this.starter = NULL;
+        this.last = NULL;
+}
 void ?{}(coroutine_desc* this, size_t size) {
+void ?{}(coroutine_desc& this, size_t size) {
         this{};
         (&this->stack){size};
+        (this.stack){size};
+}
 void ^?{}(coStack_t* this) {
         if ( ! this->userStack ) {
+void ^?{}(coStack_t& this) {
+        if ( ! this.userStack ) {
                 LIB_DEBUG_DO(
                         if ( mprotect( this->storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
                                 abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", this, errno, strerror( errno ) );
+                        if ( mprotect( this.storage, pageSize, PROT_READ | PROT_WRITE ) == -1 ) {
+                                abortf( "(coStack_t *)%p.^?{}() : internal error, mprotect failure, error(%d) %s.", &this, errno, strerror( errno ) );
+                        }
                 );
                 free( this->storage );
+                free( this.storage );
+        }
+}
 void ^?{}(coroutine_desc* this) {}
+void ^?{}(coroutine_desc& this) {}
 // Part of the Public API
 // Not inline since only ever called once per coroutine
 forall(dtype T | is_coroutine(T))
 void prime(T* cor) {
+void prime(T& cor) {
         coroutine_desc* this = get_coroutine(cor);
         assert(this->state == Start);

src/libcfa/concurrency/invoke.h

-                      r54cd58b
+                      r9236060
       #ifdef __CFORALL__
       extern "Cforall" {
             void ?{}( struct __thread_queue_t * );
+            void ?{}( struct __thread_queue_t & );
             void append( struct __thread_queue_t *, struct thread_desc * );
             struct thread_desc * pop_head( struct __thread_queue_t * );
             void ?{}( struct __condition_stack_t * );
+            void ?{}( struct __condition_stack_t & );
             void push( struct __condition_stack_t *, struct __condition_criterion_t * );
             struct __condition_criterion_t * pop( struct __condition_stack_t * );
             void ?{}(spinlock * this);
             void ^?{}(spinlock * this);
+            void ?{}(spinlock & this);
+            void ^?{}(spinlock & this);
+      }
       #endif

src/libcfa/concurrency/kernel

-                      r54cd58b
+                      r9236060
 };
 void  ?{}(semaphore * this, int count = 1);
 void ^?{}(semaphore * this);
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
 void P(semaphore * this);
 void V(semaphore * this);
 …
 };
 void ?{}(cluster * this);
 void ^?{}(cluster * this);
+void ?{}(cluster & this);
+void ^?{}(cluster & this);
 //-----------------------------------------------------------------------------
 …
         unsigned short thrd_count;
 };
 static inline void ?{}(FinishAction * this) {
         this->action_code = No_Action;
         this->thrd = NULL;
         this->lock = NULL;
+static inline void ?{}(FinishAction & this) {
+        this.action_code = No_Action;
+        this.thrd = NULL;
+        this.lock = NULL;
+}
 static inline void ^?{}(FinishAction * this) {}
+static inline void ^?{}(FinishAction & this) {}
 // Processor
 …
 };
 void ?{}(processor * this);
 void ?{}(processor * this, cluster * cltr);
 void ^?{}(processor * this);
+void ?{}(processor & this);
+void ?{}(processor & this, cluster * cltr);
+void ^?{}(processor & this);
 // Local Variables: //

src/libcfa/concurrency/kernel.c

-                      r54cd58b
+                      r9236060
 };
 void ?{}( current_stack_info_t * this ) {
         CtxGet( this->ctx );
         this->base = this->ctx.FP;
         this->storage = this->ctx.SP;
+void ?{}( current_stack_info_t & this ) {
+        CtxGet( this.ctx );
+        this.base = this.ctx.FP;
+        this.storage = this.ctx.SP;
         rlimit r;
         getrlimit( RLIMIT_STACK, &r);
         this->size = r.rlim_cur;
         this->limit = (void *)(((intptr_t)this->base) - this->size);
         this->context = &storage_mainThreadCtx;
         this->top = this->base;
+}
 void ?{}( coStack_t * this, current_stack_info_t * info) {
         this->size = info->size;
         this->storage = info->storage;
         this->limit = info->limit;
         this->base = info->base;
         this->context = info->context;
         this->top = info->top;
         this->userStack = true;
+}
 void ?{}( coroutine_desc * this, current_stack_info_t * info) {
         (&this->stack){ info };
         this->name = "Main Thread";
         this->errno_ = 0;
         this->state = Start;
+}
 void ?{}( thread_desc * this, current_stack_info_t * info) {
         (&this->cor){ info };
+        this.size = r.rlim_cur;
+        this.limit = (void *)(((intptr_t)this.base) - this.size);
+        this.context = &storage_mainThreadCtx;
+        this.top = this.base;
+}
+void ?{}( coStack_t & this, current_stack_info_t * info) {
+        this.size = info->size;
+        this.storage = info->storage;
+        this.limit = info->limit;
+        this.base = info->base;
+        this.context = info->context;
+        this.top = info->top;
+        this.userStack = true;
+}
+void ?{}( coroutine_desc & this, current_stack_info_t * info) {
+        (this.stack){ info };
+        this.name = "Main Thread";
+        this.errno_ = 0;
+        this.state = Start;
+}
+void ?{}( thread_desc & this, current_stack_info_t * info) {
+        (this.cor){ info };
+}
 //-----------------------------------------------------------------------------
 // Processor coroutine
 void ?{}(processorCtx_t * this, processor * proc) {
         (&this->__cor){ "Processor" };
         this->proc = proc;
         proc->runner = this;
+}
 void ?{}(processorCtx_t * this, processor * proc, current_stack_info_t * info) {
         (&this->__cor){ info };
         this->proc = proc;
         proc->runner = this;
+}
 void ?{}(processor * this) {
+void ?{}(processorCtx_t & this, processor * proc) {

Context Navigation

Changes in / [54cd58b:9236060]

Legend: