Changes in src/ResolvExpr/ConversionCost.cc [cf32116:849720f]

File:

• src/ResolvExpr/ConversionCost.cc (modified) (16 diffs)

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Oct  4 14:45:00 2019
-// Update Count     : 28
+// Last Modified On : Mon Aug 12 10:21:00 2019
+// Update Count     : 27
 //
 
@@ -497 +497 @@
         }
 
-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 ); }
-}
+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 ); }
 
 Cost conversionCost(
-        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, 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, srcIsLvalue, symtab, env );
+                                return conversionCost(src, eqv->bound, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -524 +524 @@
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
-                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, symtab, env ) + Cost::safe;
                         }
                 }
@@ -534 +534 @@
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
         } else {
-                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
+                ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
                 src->accept( converter );
                 return converter.pass.cost;
@@ -542 +542 @@
 }
 
-static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+                NumCostCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
-                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
-                        srcIsLvalue, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
+                        dst, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -554 +554 @@
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
-                        srcIsLvalue, (diff + 1), symtab, env, func );
+                        (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -579 +579 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
+                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
                         src->accept( converter );
                         return converter.pass.cost;
@@ -588 +588 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( srcIsLvalue ) {
+                        if ( src->is_lvalue() ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -607 +607 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
-                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+            const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                NumCostCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
-        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
 }
 
@@ -667 +667 @@
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
-        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
+        cost = costCalc( refType->base, dst, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -701 +701 @@
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        static const ast::BasicType integer( ast::BasicType::SignedInt );
+        cost = costCalc( &integer, dst, 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, srcIsLvalue, symtab, env );
+                cost = costCalc( eqv->bound, dst, 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, srcIsLvalue, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
                 }
         }
@@ -737 +737 @@
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
-                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;
@@ -772 +772 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
-                cost = Cost::zero;
-                // +1 for zero_t ->, +1 for disambiguation
-                cost.incSafe( maxIntCost + 2 );
         }
 }
@@ -793 +789 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
+        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
+                cost = Cost::zero;
+                cost.incSafe( maxIntCost + 2 );
         }
 }