Index: src/ResolvExpr/CandidateFinder.cpp =================================================================== --- src/ResolvExpr/CandidateFinder.cpp (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/CandidateFinder.cpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -9,7 +9,7 @@ // 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,6 +62,6 @@ 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,5 +74,5 @@ 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,5 +110,6 @@ 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,5 +983,5 @@ /// 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,5 +1025,6 @@ // 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,5 +1436,6 @@ // 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 ) { Index: src/ResolvExpr/CandidateFinder.hpp =================================================================== --- src/ResolvExpr/CandidateFinder.hpp (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/CandidateFinder.hpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -9,7 +9,7 @@ // 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,6 +32,6 @@ 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,5 +49,5 @@ 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,7 +55,7 @@ /// 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 Index: src/ResolvExpr/CastCost.cc =================================================================== --- src/ResolvExpr/CastCost.cc (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/CastCost.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -10,6 +10,6 @@ // 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,7 +142,7 @@ 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,5 +152,5 @@ cost = Cost::unsafe; } else { - cost = conversionCost( basicType, dst, symtab, env ); + cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env ); } } @@ -183,9 +183,21 @@ } }; + + #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,5 +205,5 @@ // 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,5 +213,5 @@ 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,17 +236,9 @@ #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; Index: src/ResolvExpr/ConversionCost.cc =================================================================== --- src/ResolvExpr/ConversionCost.cc (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/ConversionCost.cc (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -10,6 +10,6 @@ // 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,24 +497,24 @@ } -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,5 +524,5 @@ 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,7 +534,7 @@ } 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 converter( dst, symtab, env, localConversionCost ); + ast::Pass converter( dst, srcIsLvalue, symtab, env, localConversionCost ); src->accept( converter ); return converter.pass.cost; @@ -542,11 +542,11 @@ } -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,5 +554,5 @@ 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,5 +579,5 @@ } } else { - ast::Pass converter( dst, symtab, env, localConversionCost ); + ast::Pass converter( dst, srcIsLvalue, symtab, env, localConversionCost ); src->accept( converter ); return converter.pass.cost; @@ -588,5 +588,5 @@ 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,8 +607,8 @@ 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,5 +667,5 @@ 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,5 +702,5 @@ (void)enumInstType; static ast::ptr 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,5 +714,5 @@ 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,5 +724,5 @@ 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,5 +737,5 @@ 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; Index: src/ResolvExpr/ConversionCost.h =================================================================== --- src/ResolvExpr/ConversionCost.h (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/ConversionCost.h (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -10,6 +10,6 @@ // 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,7 +74,7 @@ // Some function pointer types, differ in return type. -using CostCalculation = std::function; -using NumCostCalculation = std::function; @@ -83,4 +83,5 @@ protected: const ast::Type * dst; + bool srcIsLvalue; const ast::SymbolTable & symtab; const ast::TypeEnvironment & env; @@ -89,7 +90,8 @@ 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,5 +116,6 @@ 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 Index: src/ResolvExpr/SatisfyAssertions.cpp =================================================================== --- src/ResolvExpr/SatisfyAssertions.cpp (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/SatisfyAssertions.cpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -9,7 +9,7 @@ // 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,6 +299,6 @@ 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,9 +306,9 @@ 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,7 +317,7 @@ cost.decSpec( specCost( param->get_type() ) ); } - + cost.incVar( func->forall.size() ); - + for ( const ast::TypeDecl * td : func->forall ) { cost.decSpec( td->assertions.size() ); @@ -329,6 +329,6 @@ }; - 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 ) {} Index: src/ResolvExpr/SatisfyAssertions.hpp =================================================================== --- src/ResolvExpr/SatisfyAssertions.hpp (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/SatisfyAssertions.hpp (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -28,6 +28,6 @@ /// 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 & errors ); Index: src/ResolvExpr/typeops.h =================================================================== --- src/ResolvExpr/typeops.h (revision 90ce35aa119e12338697fb8d71481c558a92bdef) +++ src/ResolvExpr/typeops.h (revision cf32116a7c8c54e0d0839465e3e60ca0be290dbc) @@ -10,6 +10,6 @@ // 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,6 +83,6 @@ 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,6 +90,6 @@ 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