Changes in src/ResolvExpr/CastCost.cc [bd0b6b62:150ec33]

File:

• src/ResolvExpr/CastCost.cc (modified) (4 diffs)

src/ResolvExpr/CastCost.cc

@@ -31 +31 @@
 
 namespace ResolvExpr {
-        struct CastCost : public ConversionCost {
+        class CastCost : public ConversionCost {
           public:
-                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
 
-                using ConversionCost::previsit;
-                using ConversionCost::postvisit;
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
         };
 
@@ -54 +52 @@
                                 // all typedefs should be gone by this point
                                 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
-                                if ( type->base ) {
-                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
+                                if ( type->get_base() ) {
+                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -76 +74 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
+                        CastCost converter( dest, indexer, env );
                         src->accept( converter );
-                        if ( converter.pass.get_cost() == Cost::infinity ) {
+                        if ( converter.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
                                 // xxx - why are we adding cost 0 here?
-                                return converter.pass.get_cost() + Cost::zero;
+                                return converter.get_cost() + Cost::zero;
                         } // if
                 } // if
         }
 
-        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
-                : ConversionCost( dest, indexer, env, costFunc ) {
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
+                : ConversionCost( dest, indexer, env ) {
         }
 
-        void CastCost::postvisit( BasicType *basicType ) {
+        void CastCost::visit( BasicType *basicType ) {
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
@@ -105 +103 @@
         }
 
-        void CastCost::postvisit( PointerType *pointerType ) {
+        void CastCost::visit( PointerType *pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->forall );
-                                newEnv.add( pointerType->base->forall );
-                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
+                                newEnv.add( pointerType->get_forall() );
+                                newEnv.add( pointerType->get_base()->get_forall() );
+                                int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost::safe;