Changes in src/ResolvExpr/ConversionCost.cc [7e003011:cb43451]

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -21 +21 @@
 
 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 ) {
@@ -41 +46 @@
                                 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
@@ -54 +59 @@
                 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 );
@@ -63 +71 @@
                                 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 );
         }
 
@@ -157 +233 @@
                         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
         }
@@ -171 +248 @@
         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) {}
 
@@ -208 +315 @@
                 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
@@ -231 +338 @@
                         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
@@ -237 +344 @@
 
         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();
@@ -269 +376 @@
                         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;
                 }
         }
@@ -285 +393 @@
                         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 );
                         }
                 }