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

File:

• src/ResolvExpr/ConversionCost.cc (modified) (6 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 {
@@ -33 +40 @@
 #define PRINT(x)
 #endif
-
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
@@ -71 +77 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env );
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){
+                                return ptrsAssignable( t1, t2, env );
+                        });
                 } else {
                         ConversionCost converter( dest, indexer, env );
@@ -83 +91 @@
         }
 
-        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+        Cost convertToReferenceCost( Type * src, Type * dest, int diff, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
                 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 cost = convertToReferenceCost( safe_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
                         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 cost = convertToReferenceCost( src, safe_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
                         cost.incReference();
                         return cost;
@@ -103 +111 @@
                                         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 );
+                                        int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult < 0 ) {
@@ -150 +158 @@
         }
 
-        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+        Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func ) {
                 int sdepth = src->referenceDepth(), ddepth = dest->referenceDepth();
-                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env );
+                return convertToReferenceCost( src, dest, sdepth-ddepth, indexer, env, func );
         }