Changes in src/ResolvExpr/ConversionCost.cc [ecd4923:b0837e4]

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -92 +92 @@
 
         Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
-                PRINT( std::cerr << "convert to reference cost... diff " << diff << " " << src << " / " << dest << std::endl; )
+                PRINT( std::cerr << "convert to reference cost... diff " << diff << std::endl; )
                 if ( diff > 0 ) {
                         // TODO: document this
@@ -108 +108 @@
                         if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
                                 PRINT( std::cerr << "converting between references" << std::endl; )
-                                Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
-                                Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
-                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
-                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
-                                        if ( tq1 == tq2 ) {
-                                                // types are the same
-                                                return Cost::zero;
-                                        } else {
-                                                // types are the same, except otherPointer has more qualifiers
-                                                return Cost::safe;
-                                        }
+                                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 = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
@@ -257 +248 @@
         };
 
-        void ConversionCost::visit( VoidType * ) {
+        void ConversionCost::visit( __attribute((unused)) VoidType *voidType ) {
                 cost = Cost::infinity;
         }
@@ -280 +271 @@
         void ConversionCost::visit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
+                        PRINT( 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 ) ) {
-                                PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                 if ( tq1 == tq2 ) {
                                         // types are the same
@@ -290 +280 @@
                                 } else {
                                         // types are the same, except otherPointer has more qualifiers
+                                        PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         cost = Cost::safe;
                                 }
-                        } else {
+                        } else {  // xxx - this discards qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
                                 int assignResult = ptrsAssignable( pointerType->base, destAsPtr->base, env );
                                 PRINT( std::cerr << " :: " << assignResult << std::endl; )
-                                if ( assignResult > 0 && tq1 <= tq2 ) {
-                                        // xxx - want the case where qualifiers are added to be more expensive than the case where qualifiers are the same. Is 1 safe vs. 2 safe correct?
-                                        if ( tq1 == tq2 ) {
-                                                cost = Cost::safe;
-                                        } else if ( tq1 < tq2 ) {
-                                                cost = Cost::safe+Cost::safe;
-                                        }
+                                if ( assignResult > 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
+                                        cost = Cost::safe;
                                 } else if ( assignResult < 0 ) {
                                         cost = Cost::unsafe;