Changeset 90152a4 for src/ResolvExpr/CastCost.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

src/ResolvExpr/CastCost.cc

@@ -31 +31 @@
 
 namespace ResolvExpr {
-        class CastCost : public ConversionCost {
+        struct CastCost : public ConversionCost {
           public:
-                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
-                virtual void visit( BasicType *basicType );
-                virtual void visit( PointerType *pointerType );
+                using ConversionCost::previsit;
+                using ConversionCost::postvisit;
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
         };
 
         Cost castCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env ) {
                 if ( TypeInstType *destAsTypeInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        EqvClass eqvClass;
-                        NamedTypeDecl *namedType;
-                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                                if ( eqvClass.type ) {
-                                        return castCost( src, eqvClass.type, indexer, env );
+                        if ( const EqvClass* eqvClass = env.lookup( destAsTypeInst->get_name() ) ) {
+                                if ( eqvClass->type ) {
+                                        return castCost( src, eqvClass->type, indexer, env );
                                 } else {
                                         return Cost::infinity;
                                 }
-                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                        } else if ( NamedTypeDecl *namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) {
                                 // all typedefs should be gone by this point
                                 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
-                                if ( type->get_base() ) {
-                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                if ( type->base ) {
+                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -74 +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 TypeEnvironment & env, const SymTab::Indexer & indexer) {
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        CastCost converter( dest, indexer, env );
+                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
                                 // xxx - why are we adding cost 0 here?
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
         }
 
-        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : ConversionCost( dest, indexer, env ) {
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : ConversionCost( dest, indexer, env, costFunc ) {
         }
 
-        void CastCost::visit( BasicType *basicType ) {
+        void CastCost::postvisit( BasicType *basicType ) {
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
@@ -103 +103 @@
         }
 
-        void CastCost::visit( PointerType *pointerType ) {
+        void CastCost::postvisit( PointerType *pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->get_forall() );
-                                newEnv.add( pointerType->get_base()->get_forall() );
-                                int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
+                                newEnv.add( pointerType->forall );
+                                newEnv.add( pointerType->base->forall );
+                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost::safe;