Changeset cb43451 for src/ResolvExpr/ConversionCost.cc

Timestamp:

Jul 21, 2017, 9:51:17 AM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

53a8e68

Parents:

17f22e78

Message:

Fix reference conversion cost for qualified references and add pass that removes redundant *&/&* pattern

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -248 +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::safe;
-                        } else {  // xxx - this discards pointer qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
+                        // 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 ) {
+                                // 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::unsafe;
                                 } // if
+                                // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
@@ -272 +284 @@
                 // cv can be safely dropped because of 'implicit dereference' behavior.
                 refType->get_base()->accept( *this );
-                cost.incReference();
+                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;
         }