Changes in src/ResolvExpr/ConversionCost.cc [5ccb10d:ea6332d]

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -15 +15 @@
 
 #include "ConversionCost.h"
-#include "typeops.h"
-#include "SynTree/Type.h"
-#include "SynTree/Visitor.h"
-#include "SymTab/Indexer.h"
+
+#include <cassert>                       // for assert
+#include <list>                          // for list, list<>::const_iterator
+#include <string>                        // for operator==, string
+
+#include "ResolvExpr/Cost.h"             // for Cost
+#include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
+#include "SymTab/Indexer.h"              // for Indexer
+#include "SynTree/Declaration.h"         // for TypeDecl, NamedTypeDecl
+#include "SynTree/Type.h"                // for Type, BasicType, TypeInstType
+#include "typeops.h"                     // for typesCompatibleIgnoreQualifiers
 
 namespace ResolvExpr {
-        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 );
-
-#if 0
-#define PRINT(x) x
-#else
-#define PRINT(x)
-#endif
+        const Cost Cost::zero = Cost( 0, 0, 0 );
+        const Cost Cost::infinity = Cost( -1, -1, -1 );
 
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
@@ -38 +35 @@
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
-                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
+///     std::cout << "type inst " << destAsTypeInst->get_name();
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
                                 if ( eqvClass.type ) {
@@ -46 +43 @@
                                 }
                         } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
-                                PRINT( std::cerr << " found" << std::endl; )
+///       std::cout << " found" << std::endl;
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
                                 assert( type );
                                 if ( type->get_base() ) {
-                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost( 0, 0, 1 );
                                 } // if
                         } // if
-                        PRINT( std::cerr << " not found" << std::endl; )
-                } // if
-                PRINT(
-                        std::cerr << "src is ";
-                        src->print( std::cerr );
-                        std::cerr << std::endl << "dest is ";
-                        dest->print( std::cerr );
-                        std::cerr << std::endl << "env is" << std::endl;
-                        env.print( std::cerr, 8 );
-                )
+///     std::cout << " not found" << std::endl;
+                } // if
+///   std::cout << "src is ";
+///   src->print( std::cout );
+///   std::cout << std::endl << "dest is ";
+///   dest->print( std::cout );
+///   std::cout << std::endl << "env is" << std::endl;
+///   env.print( std::cout, 8 );
                 if ( typesCompatibleIgnoreQualifiers( src, dest, indexer, env ) ) {
-                        PRINT( std::cerr << "compatible!" << std::endl; )
-                        return Cost::zero;
+///     std::cout << "compatible!" << std::endl;
+                        return Cost( 0, 0, 0 );
                 } else if ( dynamic_cast< VoidType* >( dest ) ) {
-                        return Cost::safe;
-                } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
-                        PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env );
+                        return Cost( 0, 0, 1 );
                 } else {
                         ConversionCost converter( dest, indexer, env );
@@ -78 +70 @@
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost::zero;
-                        } // if
-                } // if
-        }
-
-        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
-                PRINT( 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
-                                PRINT( 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 );
-                                        PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
-                                        if ( assignResult < 0 ) {
-                                                return Cost::safe;
-                                        } else if ( assignResult > 0 ) {
-                                                return Cost::unsafe;
-                                        } // if
-                                } // if
-                        } else {
-                                PRINT( 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 ) ) {
-                                PRINT( std::cerr << "converting compatible base type" << std::endl; )
-                                if ( src->get_lvalue() ) {
-                                        PRINT(
-                                                std::cerr << "lvalue to reference conversion" << std::endl;
-                                                std::cerr << src << " => " << destAsRef << 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() ) {
-                                        PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
-                                        // rvalue-to-const-reference conversion: T => const T &
-                                        return Cost::safe;
-                                } else {
-                                        PRINT( std::cerr << "rvalue to non-const reference conversion" << std::endl; )
-                                        // rvalue-to-reference conversion: T => T &
-                                        return Cost::unsafe;
-                                } // if
-                        } // if
-                        PRINT( 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 );
+                                return converter.get_cost() + Cost( 0, 0, 0 );
+                        } // if
+                } // if
         }
 
@@ -244 +164 @@
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult );
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult );
                         } // if
                 } else if ( dynamic_cast< EnumInstType *>( dest ) ) {
                         // xxx - not positive this is correct, but appears to allow casting int => enum
-                        cost = Cost::unsafe;
+                        cost = Cost( 1, 0, 0 );
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost::unsafe;
+                        cost = Cost( 1, 0, 0 );
                 } // if
         }
@@ -259 +178 @@
         void ConversionCost::visit(PointerType *pointerType) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        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 ) ) {
-                                if ( tq1 == tq2 ) {
-                                        // types are the same
-                                        cost = Cost::zero;
-                                } else {
-                                        // types are the same, except otherPointer has more qualifiers
-                                        PRINT( 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?
+                        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 {
                                 int assignResult = ptrsAssignable( pointerType->get_base(), destAsPtr->get_base(), env );
-                                PRINT( std::cerr << " :: " << assignResult << std::endl; )
-                                if ( assignResult < 0 && pointerType->get_base()->get_qualifiers() <= destAsPtr->get_qualifiers() ) {
-                                        cost = Cost::safe;
+                                if ( assignResult < 0 ) {
+                                        cost = Cost( 0, 0, 1 );
                                 } else if ( assignResult > 0 ) {
-                                        cost = Cost::unsafe;
+                                        cost = Cost( 1, 0, 0 );
                                 } // if
-                                // assignResult == 0 means Cost::Infinity
                         } // if
                 } else if ( dynamic_cast< ZeroType* >( dest ) != nullptr || dynamic_cast< OneType* >( dest ) != nullptr ) {
-                        cost = Cost::unsafe;
+                        cost = Cost( 1, 0, 0 );
                 } // 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
-                }
-                PRINT( std::cerr << refType << " ==> " << dest << " " << cost << std::endl; )
-        }
-
         void ConversionCost::visit(__attribute((unused)) FunctionType *functionType) {}
 
@@ -326 +215 @@
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );  // safe if dest >= int
-                if ( cost < Cost::unsafe ) {
+                integer.accept( *this );
+                if ( cost < Cost( 1, 0, 0 ) ) {
                         cost.incSafe();
                 } // if
@@ -349 +238 @@
                         assert( type );
                         if ( type->get_base() ) {
-                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
+                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost( 0, 0, 1 );
                         } // if
                 } // if
@@ -355 +244 @@
 
         void ConversionCost::visit( __attribute((unused)) TupleType *tupleType) {
-                Cost c = Cost::zero;
+                Cost c;
                 if ( TupleType *destAsTuple = dynamic_cast< TupleType* >( dest ) ) {
                         std::list< Type* >::const_iterator srcIt = tupleType->get_types().begin();
@@ -387 +276 @@
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult + 1 );
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
                         }
                 } else if ( dynamic_cast< PointerType* >( dest ) ) {
-                        cost = Cost::safe;
+                        cost = Cost( 0, 0, 1 );
                 }
         }
@@ -404 +292 @@
                         int tableResult = costMatrix[ BasicType::SignedInt ][ destAsBasic->get_kind() ];
                         if ( tableResult == -1 ) {
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = Cost::zero;
-                                cost.incSafe( tableResult + 1 );
+                                cost = Cost( 1, 0, 0 );
+                        } else {
+                                cost = Cost( 0, 0, tableResult + 1 );
                         }
                 }