Changeset cf32116

Timestamp:

Oct 4, 2019, 3:07:07 PM (5 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

3f3bfe5a

Parents:

90ce35aa

Message:

Implemented expression based lvalue resolution on new ast.

Location:

src

Files:

• AST/Expr.cpp (modified) (13 diffs)
• AST/Expr.hpp (modified) (11 diffs)
• ResolvExpr/CandidateFinder.cpp (modified) (7 diffs)
• ResolvExpr/CandidateFinder.hpp (modified) (4 diffs)
• ResolvExpr/CastCost.cc (modified) (7 diffs)
• ResolvExpr/ConversionCost.cc (modified) (14 diffs)
• ResolvExpr/ConversionCost.h (modified) (5 diffs)
• ResolvExpr/SatisfyAssertions.cpp (modified) (5 diffs)
• ResolvExpr/SatisfyAssertions.hpp (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (3 diffs)

src/AST/Expr.cpp

@@ -10 +10 @@
 // Created On       : Wed May 15 17:00:00 2019
 // Last Modified By : Andrew Beach
-// Created On       : Thr Jun 13 13:38:00 2019
-// Update Count     : 2
+// Created On       : Thr Jun 26 12:12:00 2019
+// Update Count     : 3
 //
 
@@ -23 +23 @@
 #include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
+#include "LinkageSpec.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
@@ -29 +30 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "InitTweak/InitTweak.h"   // for getFunction, getPointerBase
 #include "ResolvExpr/typeops.h"    // for extractResultType
 #include "Tuples/Tuples.h"         // for makeTupleType
 
 namespace ast {
+
+namespace {
+        std::set<std::string> const lvalueFunctionNames = {"*?", "?[?]"};
+}
+
+// --- Expr
+bool Expr::get_lvalue() const {
+        return false;
+}
 
 // --- ApplicationExpr
@@ -46 +56 @@
         result = ResolvExpr::extractResultType( fn );
         assert( result );
+}
+
+bool ApplicationExpr::get_lvalue() const {
+        if ( const DeclWithType * func = InitTweak::getFunction( this ) ) {
+                return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name );
+        }
+        return false;
 }
 
@@ -71 +88 @@
 }
 
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
+}
+
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
         assert( lhs && rhs );
@@ -106 +128 @@
 AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
         if ( arg->result ) {
-                if ( arg->result->is_lvalue() ) {
+                if ( arg->get_lvalue() ) {
                         // lvalue, retains all levels of reference, and gains a pointer inside the references
                         Type * res = addrType( arg->result );
@@ -137 +159 @@
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
 
+bool CastExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return arg->get_lvalue();
+}
+
 // --- KeywordCastExpr
 
@@ -150 +177 @@
 }
 
+// --- UntypedMemberExpr
+
+bool UntypedMemberExpr::get_lvalue() const {
+        return aggregate->get_lvalue();
+}
+
 // --- MemberExpr
 
@@ -210 +243 @@
 }
 
+bool MemberExpr::get_lvalue() const {
+        // This is actually wrong by C, but it works with our current set-up.
+        return true;
+}
+
 // --- VariableExpr
 
@@ -222 +260 @@
         r->qualifiers |= CV::Lvalue;
         result = r;
+}
+
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
 }
 
@@ -308 +351 @@
 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
 
+// --- CommaExpr
+bool CommaExpr::get_lvalue() const {
+        // This is wrong by C, but the current implementation uses it.
+        // (ex: Specialize, Lvalue and Box)
+        return arg2->get_lvalue();
+}
+
 // --- ConstructorExpr
 
@@ -329 +379 @@
 }
 
+bool CompoundLiteralExpr::get_lvalue() const {
+        return true;
+}
+
 // --- TupleExpr
 
@@ -344 +398 @@
         result = type->types[ index ];
         add_qualifiers( result, CV::Lvalue );
+}
+
+bool TupleIndexExpr::get_lvalue() const {
+        return tuple->get_lvalue();
 }
 

src/AST/Expr.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Fri May 10 10:30:00 2019
-// Last Modified By : Aaron B. Moss
-// Created On       : Fri May 10 10:30:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Created On       : Thr Sep 26 12:51:00 2019
+// Update Count     : 2
 //
 
@@ -187 +187 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
+        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -203 +204 @@
         ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -217 +220 @@
         UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
         : Expr( loc ), func( f ), args( std::move(as) ) {}
+
+        bool get_lvalue() const final;
 
         /// Creates a new dereference expression
@@ -293 +298 @@
         CastExpr( const Expr * a ) : CastExpr( a->location, a, GeneratedCast ) {}
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -340 +347 @@
         : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -353 +362 @@
 
         MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
+
+        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -374 +385 @@
         VariableExpr( const CodeLocation & loc );
         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
 
         /// generates a function pointer for a given function
@@ -545 +558 @@
         }
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -616 +631 @@
         CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
 
+        bool get_lvalue() const final;
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -671 +688 @@
 
         TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i );
+
+        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/ResolvExpr/CandidateFinder.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed Jun 5 14:30:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1 14:55:00 2019
+// Update Count     : 2
 //
 
@@ -62 +62 @@
 
 Cost computeConversionCost(
-        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
+        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         PRINT(
@@ -74 +74 @@
                 std::cerr << std::endl;
         )
-        Cost convCost = conversionCost( argType, paramType, symtab, env );
+        Cost convCost = conversionCost( argType, paramType, argIsLvalue, symtab, env );
         PRINT(
                 std::cerr << std::endl << "cost is " << convCost << std::endl;
@@ -110 +110 @@
                 const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
         ) {
-                Cost convCost = computeConversionCost( arg->result, paramType, symtab, env );
+                Cost convCost = computeConversionCost(
+                                arg->result, paramType, arg->get_lvalue(), symtab, env );
                 outCost += convCost;
 
@@ -982 +983 @@
                 /// true if expression is an lvalue
                 static bool isLvalue( const ast::Expr * x ) {
-                        return x->result && ( x->result->is_lvalue() || x->result.as< ast::ReferenceType >() );
+                        return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() );
                 }
 
@@ -1024 +1025 @@
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost = castCost( cand->expr->result, toType, symtab, cand->env );
+                                Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, cand->env );
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
@@ -1434 +1436 @@
                                         // unification run for side-effects
                                         unify( toType, cand->expr->result, env, need, have, open, symtab );
-                                        Cost thisCost = castCost( cand->expr->result, toType, symtab, env );
+                                        Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                        symtab, env );
 
                                         if ( thisCost != Cost::infinity ) {

src/ResolvExpr/CandidateFinder.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed Jun 5 14:30:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1  9:51:00 2019
+// Update Count     : 2
 //
 
@@ -32 +32 @@
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
 
-        CandidateFinder( 
-                const ast::SymbolTable & syms, const ast::TypeEnvironment & env, 
+        CandidateFinder(
+                const ast::SymbolTable & syms, const ast::TypeEnvironment & env,
                 const ast::Type * tt = nullptr )
         : candidates(), localSyms( syms ), env( env ), targetType( tt ) {}
@@ -49 +49 @@
         iterator begin() { return candidates.begin(); }
         const_iterator begin() const { return candidates.begin(); }
-        
+
         iterator end() { return candidates.end(); }
         const_iterator end() const { return candidates.end(); }
@@ -55 +55 @@
 
 /// Computes conversion cost between two types
-Cost computeConversionCost( 
-        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, 
-        const ast::TypeEnvironment & env );
+Cost computeConversionCost(
+        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
 
 } // namespace ResolvExpr

src/ResolvExpr/CastCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 06:57:43 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Aug  8 16:12:00 2019
-// Update Count     : 8
+// Last Modified On : Tue Oct  4 15:00:00 2019
+// Update Count     : 9
 //
 
@@ -142 +142 @@
 
                 CastCost_new(
-                        const ast::Type * dst, const ast::SymbolTable & symtab,
+                        const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costFunc )
-                : ConversionCost_new( dst, symtab, env, costFunc ) {}
+                : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {}
 
                 void postvisit( const ast::BasicType * basicType ) {
@@ -152 +152 @@
                                 cost = Cost::unsafe;
                         } else {
-                                cost = conversionCost( basicType, dst, symtab, env );
+                                cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
                         }
                 }
@@ -183 +183 @@
                 }
         };
+
+        #warning For overload resolution between the two versions.
+        int localPtrsCastable(const ast::Type * t1, const ast::Type * t2,
+                        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) {
+                return ptrsCastable( t1, t2, symtab, env );
+        }
+        Cost localCastCost(
+                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        ) { return castCost( src, dst, srcIsLvalue, symtab, env ); }
 } // anonymous namespace
 
+
+
 Cost castCost(
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -193 +205 @@
                         // check cast cost against bound type, if present
                         if ( eqvClass->bound ) {
-                                return castCost( src, eqvClass->bound, symtab, env );
+                                return castCost( src, eqvClass->bound, srcIsLvalue, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -201 +213 @@
                         auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
                         if ( type->base ) {
-                                return castCost( src, type->base, symtab, env ) + Cost::safe;
+                                return castCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
                         }
                 }
@@ -224 +236 @@
                 #warning cast on ptrsCastable artifact of having two functions, remove when port done
                 return convertToReferenceCost(
-                        src, refType, symtab, env,
-                        ( int (*)(
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
-                                const ast::TypeEnvironment & )
-                        ) ptrsCastable );
+                        src, refType, srcIsLvalue, symtab, env, localPtrsCastable );
         } else {
                 #warning cast on castCost artifact of having two functions, remove when port done
-                ast::Pass< CastCost_new > converter{
-                        dst, symtab, env,
-                        ( Cost (*)(
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
-                                const ast::TypeEnvironment & )
-                        ) castCost };
+                ast::Pass< CastCost_new > converter(
+                        dst, srcIsLvalue, symtab, env, localCastCost );
                 src->accept( converter );
                 return converter.pass.cost;

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thr Jul  4 10:56:00 2019
-// Update Count     : 27
+// Last Modified On : Fri Oct  4 14:45:00 2019
+// Update Count     : 28
 //
 
@@ -497 +497 @@
         }
 
-static int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
-                const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
-        return ptrsAssignable( t1, t2, env );
-}
-
-// TODO: This is used for overload resolution. It might be able to be dropped once the old system
-// is removed.
-static Cost localConversionCost(
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
-) { return conversionCost( src, dst, symtab, env ); }
+namespace {
+        # warning For overload resolution between the two versions.
+        int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
+                        const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
+                return ptrsAssignable( t1, t2, env );
+        }
+        Cost localConversionCost(
+                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
+}
 
 Cost conversionCost(
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
                         if ( eqv->bound ) {
-                                return conversionCost(src, eqv->bound, symtab, env );
+                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -524 +524 @@
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
-                                return conversionCost( src, type->base, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
                         }
                 }
@@ -534 +534 @@
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
         } else {
-                ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                 src->accept( converter );
                 return converter.pass.cost;
@@ -542 +542 @@
 }
 
-static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                NumCostCalculation func ) {
+                PtrsCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
-                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
-                        dst, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
+                        srcIsLvalue, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -554 +554 @@
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
-                        (diff + 1), symtab, env, func );
+                        srcIsLvalue, (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -579 +579 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                         src->accept( converter );
                         return converter.pass.cost;
@@ -588 +588 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( src->is_lvalue() ) {
+                        if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -607 +607 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
-            const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                NumCostCalculation func ) {
+                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                PtrsCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
-        return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
 }
 
@@ -667 +667 @@
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
-        cost = costCalc( refType->base, dst, symtab, env );
+        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -702 +702 @@
         (void)enumInstType;
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, symtab, env );
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -714 +714 @@
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
         if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
-                cost = costCalc( eqv->bound, dst, symtab, env );
+                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -724 +724 @@
                 assertf( type, "Unexpected typedef.");
                 if ( type->base ) {
-                        cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
                 }
         }
@@ -737 +737 @@
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
-                        Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;

src/ResolvExpr/ConversionCost.h

@@ -10 +10 @@
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Aug  8 16:13:00 2019
-// Update Count     : 6
+// Last Modified On : Tue Oct  4 14:59:00 2019
+// Update Count     : 7
 //
 
@@ -74 +74 @@
 
 // Some function pointer types, differ in return type.
-using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *,
+using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *, bool,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
-using NumCostCalculation = std::function<int(const ast::Type *, const ast::Type *,
+using PtrsCalculation = std::function<int(const ast::Type *, const ast::Type *,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
 
@@ -83 +83 @@
 protected:
         const ast::Type * dst;
+        bool srcIsLvalue;
         const ast::SymbolTable & symtab;
         const ast::TypeEnvironment & env;
@@ -89 +90 @@
         Cost cost;
 
-        ConversionCost_new( const ast::Type * dst, const ast::SymbolTable & symtab,
+        ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costCalc ) :
-                dst( dst ), symtab( symtab ), env( env ), costCalc( costCalc ), cost( Cost::infinity )
+                dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ),
+                costCalc( costCalc ), cost( Cost::infinity )
         {}
 
@@ -114 +116 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest,
-        const ast::SymbolTable & indexer, const ast::TypeEnvironment & env, NumCostCalculation func );
+        bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env,
+        PtrsCalculation func );
 
 } // namespace ResolvExpr

src/ResolvExpr/SatisfyAssertions.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Mon Jun 10 17:45:00 2019
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Mon Jun 10 17:45:00 2019
-// Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1 13:56:00 2019
+// Update Count     : 2
 //
 
@@ -299 +299 @@
                         Cost cost;
 
-                        OutType( 
-                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o, 
+                        OutType(
+                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
                                 const std::vector< DeferRef > & as, const ast::SymbolTable & symtab )
                         : env( e ), open( o ), assns( as ), cost( Cost::zero ) {
@@ -306 +306 @@
                                 for ( const DeferRef & assn : assns ) {
                                         // compute conversion cost from satisfying decl to assertion
-                                        cost += computeConversionCost( 
-                                                assn.match.adjType, assn.decl->get_type(), symtab, env );
-                                        
+                                        cost += computeConversionCost(
+                                                assn.match.adjType, assn.decl->get_type(), false, symtab, env );
+
                                         // mark vars+specialization on function-type assertions
-                                        const ast::FunctionType * func = 
+                                        const ast::FunctionType * func =
                                                 GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                         if ( ! func ) continue;
@@ -317 +317 @@
                                                 cost.decSpec( specCost( param->get_type() ) );
                                         }
-                                        
+
                                         cost.incVar( func->forall.size() );
-                                        
+
                                         for ( const ast::TypeDecl * td : func->forall ) {
                                                 cost.decSpec( td->assertions.size() );
@@ -329 +329 @@
                 };
 
-                CandidateEnvMerger( 
-                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open, 
+                CandidateEnvMerger(
+                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
                         const ast::SymbolTable & syms )
                 : crnt(), envs{ env }, opens{ open }, symtab( syms ) {}

src/ResolvExpr/SatisfyAssertions.hpp

@@ -28 +28 @@
 
 /// Recursively satisfies all assertions provided in a candidate; returns true if succeeds
-void satisfyAssertions( 
-        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out, 
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
         std::vector<std::string> & errors );
 

src/ResolvExpr/typeops.h

@@ -10 +10 @@
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Thu Aug  8 16:36:00 2019
-// Update Count     : 5
+// Last Modified On : Tue Oct  1 09:45:00 2019
+// Update Count     : 6
 //
 
@@ -83 +83 @@
                 const SymTab::Indexer & indexer, const TypeEnvironment & env );
         Cost castCost(
-                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-                const ast::TypeEnvironment & env );
+                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
 
         // in ConversionCost.cc
@@ -90 +90 @@
                 const SymTab::Indexer & indexer, const TypeEnvironment & env );
         Cost conversionCost(
-                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-                const ast::TypeEnvironment & env );
+                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
 
         // in AlternativeFinder.cc