Changes in src/ResolvExpr/CastCost.cc [3c89751:c8e4d2f8]

File:

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

src/ResolvExpr/CastCost.cc

@@ -16 +16 @@
 #include <cassert>                       // for assert
 
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
-#include "AST/TypeEnvironment.hpp"
 #include "ConversionCost.h"              // for ConversionCost
 #include "Cost.h"                        // for Cost, Cost::infinity
@@ -35 +31 @@
 
 namespace ResolvExpr {
-        struct CastCost_old : public ConversionCost {
+        struct CastCost : public ConversionCost {
           public:
-                CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
                 using ConversionCost::previsit;
@@ -82 +78 @@
                         });
                 } else {
-                        PassVisitor<CastCost_old> converter( 
+                        #warning cast on castCost artifact of having two functions, remove when port done
+                        PassVisitor<CastCost> converter( 
                                 dest, indexer, env, 
                                 (Cost (*)( Type *, Type *, const SymTab::Indexer &, const TypeEnvironment & ))
@@ -96 +93 @@
         }
 
-        CastCost_old::CastCost_old( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
                 : ConversionCost( dest, indexer, env, costFunc ) {
         }
 
-        void CastCost_old::postvisit( BasicType *basicType ) {
+        void CastCost::postvisit( BasicType *basicType ) {
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
@@ -110 +107 @@
         }
 
-        void CastCost_old::postvisit( PointerType *pointerType ) {
+        void CastCost::postvisit( PointerType *pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
@@ -133 +130 @@
         }
 
-namespace {
-        struct CastCost_new : public ConversionCost_new {
-                using ConversionCost_new::previsit;
-                using ConversionCost_new::postvisit;
-
-                CastCost_new( 
-                        const ast::Type * dst, const ast::SymbolTable & symtab, 
-                        const ast::TypeEnvironment & env, CostCalculation costFunc )
-                : ConversionCost_new( dst, symtab, env, costFunc ) {}
-
-                void postvisit( const ast::BasicType * basicType ) {
-                        auto ptr = dynamic_cast< const ast::PointerType * >( dst );
-                        if ( ptr && basicType->isInteger() ) {
-                                // needed for, e.g. unsigned long => void *
-                                cost = Cost::unsafe;
-                        } else {
-                                cost = conversionCost( basicType, dst, symtab, env );
-                        }
-                }
-
-                void postvisit( const ast::PointerType * pointerType ) {
-                        if ( auto ptr = dynamic_cast< const ast::PointerType * >( dst ) ) {
-                                if (
-                                        pointerType->qualifiers <= ptr->qualifiers
-                                        && typesCompatibleIgnoreQualifiers( pointerType->base, ptr->base, symtab, env )
-                                ) {
-                                        cost = Cost::safe;
-                                } else {
-                                        ast::TypeEnvironment newEnv{ env };
-                                        if ( auto wParams = pointerType->base.as< ast::ParameterizedType >() ) {
-                                                newEnv.add( wParams->forall );
-                                        }
-                                        int castResult = ptrsCastable( pointerType->base, ptr->base, symtab, newEnv );
-                                        if ( castResult > 0 ) {
-                                                cost = Cost::safe;
-                                        } else if ( castResult < 0 ) {
-                                                cost = Cost::infinity;
-                                        }
-                                }
-                        } else if ( auto basic = dynamic_cast< const ast::BasicType * >( dst ) ) {
-                                if ( basic->isInteger() ) {
-                                        // necessary for, e.g. void * => unsigned long
-                                        cost = Cost::unsafe;
-                                }
-                        }
-                }
-        };
-} // anonymous namespace
-
-Cost castCost( 
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
-        const ast::TypeEnvironment & env 
-) {
-        if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
-                if ( const ast::EqvClass * eqvClass = env.lookup( typeInst->name ) ) {
-                        // check cast cost against bound type, if present
-                        if ( eqvClass->bound ) {
-                                return castCost( src, eqvClass->bound, symtab, env );
-                        } else {
-                                return Cost::infinity;
-                        }
-                } else if ( const ast::NamedTypeDecl * named = symtab.lookupType( typeInst->name ) ) {
-                        // all typedefs should be gone by now
-                        auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
-                        if ( type->base ) {
-                                return castCost( src, type->base, symtab, env ) + Cost::safe;
-                        }
-                }
+        Cost castCost( 
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab, 
+                const ast::TypeEnvironment & env 
+        ) {
+                #warning unimplmented
+                (void)src; (void)dst; (void)symtab; (void)env;
+                assert(false);
+                return Cost::zero;
         }
-
-        PRINT(
-                std::cerr << "castCost ::: src is ";
-                ast::print( std::cerr, src );
-                std::cerr << std::endl << "dest is ";
-                ast::print( std::cerr, dst );
-                std::cerr << std::endl << "env is" << std::endl;
-                ast::print( std::cerr, env, 2 );
-        )
-
-        if ( typesCompatibleIgnoreQualifiers( src, dst, symtab, env ) ) {
-                PRINT( std::cerr << "compatible!" << std::endl; )
-                return Cost::zero;
-        } else if ( dynamic_cast< const ast::VoidType * >( dst ) ) {
-                return Cost::safe;
-        } else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                #warning cast on ptrsCastable artifact of having two functions, remove when port done
-                return convertToReferenceCost( 
-                        src, refType, symtab, env, 
-                        ( int (*)( 
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
-                                const ast::TypeEnvironment & )
-                        ) ptrsCastable );
-        } else {
-                #warning cast on castCost artifact of having two functions, remove when port done
-                ast::Pass< CastCost_new > converter{
-                        dst, symtab, env, 
-                        ( Cost (*)( 
-                                const ast::Type *, const ast::Type *, const ast::SymbolTable &, 
-                                const ast::TypeEnvironment & )
-                        ) castCost };
-                src->accept( converter );
-                return converter.pass.cost;
-        }
-}
-
 } // namespace ResolvExpr