Changeset 7416d46a for src/ResolvExpr/ConversionCost.cc

Timestamp:

Jan 30, 2018, 3:54:32 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

633a642

Parents:

f792cb8 (diff), 42be3c3 (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -44 +44 @@
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
-                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
-                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
+                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
                                 if ( eqvClass.type ) {
                                         return conversionCost( src, eqvClass.type, indexer, env );
@@ -51 +51 @@
                                         return Cost::infinity;
                                 }
-                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
                                 PRINT( std::cerr << " 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;
+                                if ( type->base ) {
+                                        return conversionCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -77 +77 @@
                 } 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 &){
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
                                 return ptrsAssignable( t1, t2, env );
                         });
                 } else {
-                        ConversionCost converter( dest, indexer, env );
+                        PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
@@ -95 +95 @@
                 if ( diff > 0 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
                         cost.incReference();
                         return cost;
                 } else if ( diff < -1 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
                         cost.incReference();
                         return cost;
@@ -108 +108 @@
                         if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
                                 PRINT( std::cerr << "converting between references" << std::endl; )
-                                Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
-                                Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
-                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
+                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
+                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
                                         PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         if ( tq1 == tq2 ) {
@@ -120 +120 @@
                                         }
                                 } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-                                        int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
+                                        int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult > 0 ) {
@@ -130 +130 @@
                         } else {
                                 PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
-                                ConversionCost converter( dest, indexer, env );
+                                PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                                 src->accept( converter );
-                                return converter.get_cost();
+                                return converter.pass.get_cost();
                         } // if
                 } else {
@@ -138 +138 @@
                         assert( diff == -1 && destAsRef );
                         PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
-                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )
                                 if ( src->get_lvalue() ) {
@@ -146 +146 @@
                                         )
                                         // lvalue-to-reference conversion:  cv lvalue T => cv T &
-                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
                                                 return Cost::reference; // cost needs to be non-zero to add cast
-                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                        } if ( src->get_qualifiers() < destAsRef->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() ) {
+                                } else if ( destAsRef->base->get_const() ) {
                                         PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
                                         // rvalue-to-const-reference conversion: T => const T &
@@ -173 +173 @@
         }
 
-        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {
+        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
         }
 
@@ -257 +257 @@
         };
 
-        void ConversionCost::visit( VoidType * ) {
+        void ConversionCost::postvisit( VoidType * ) {
                 cost = Cost::infinity;
         }
 
-        void ConversionCost::visit(BasicType *basicType) {
+        void ConversionCost::postvisit(BasicType *basicType) {
                 if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
@@ -278 +278 @@
         }
 
-        void ConversionCost::visit( PointerType * pointerType ) {
+        void ConversionCost::postvisit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
-                        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 ) ) {
+                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                 if ( tq1 == tq2 ) {
@@ -312 +312 @@
         }
 
-        void ConversionCost::visit( ArrayType * ) {}
-
-        void ConversionCost::visit( ReferenceType * refType ) {
+        void ConversionCost::postvisit( ArrayType * ) {}
+
+        void ConversionCost::postvisit( ReferenceType * refType ) {
                 // Note: dest can never be a reference, since it would have been caught in an earlier check
                 assert( ! dynamic_cast< ReferenceType * >( dest ) );
@@ -320 +320 @@
                 // recursively compute conversion cost from T1 to T2.
                 // cv can be safely dropped because of 'implicit dereference' behavior.
-                refType->base->accept( *this );
+                cost = costFunc( refType->base, dest, indexer, env );
                 if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
                         cost.incReference();  // prefer exact qualifiers
@@ -331 +331 @@
         }
 
-        void ConversionCost::visit( FunctionType * ) {}
-
-        void ConversionCost::visit( StructInstType * inst ) {
+        void ConversionCost::postvisit( FunctionType * ) {}
+
+        void ConversionCost::postvisit( StructInstType * inst ) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -341 +341 @@
         }
 
-        void ConversionCost::visit( UnionInstType * inst ) {
+        void ConversionCost::postvisit( UnionInstType * inst ) {
                 if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -349 +349 @@
         }
 
-        void ConversionCost::visit( EnumInstType * ) {
+        void ConversionCost::postvisit( EnumInstType * ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );  // safe if dest >= int
+                cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
                 if ( cost < Cost::unsafe ) {
                         cost.incSafe();
@@ -358 +358 @@
         }
 
-        void ConversionCost::visit( TraitInstType * ) {}
-
-        void ConversionCost::visit( TypeInstType *inst ) {
+        void ConversionCost::postvisit( TraitInstType * ) {}
+
+        void ConversionCost::postvisit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
-                if ( env.lookup( inst->get_name(), eqvClass ) ) {
-                        cost = conversionCost( eqvClass.type, dest, indexer, env );
+                if ( env.lookup( inst->name, eqvClass ) ) {
+                        cost = costFunc( eqvClass.type, dest, indexer, env );
                 } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( inst->get_name() == destAsInst->get_name() ) {
+                        if ( inst->name == destAsInst->name ) {
                                 cost = Cost::zero;
                         }
-                } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
+                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
                         TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                         // all typedefs should be gone by this point
                         assert( type );
-                        if ( type->get_base() ) {
-                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
-                        } // if
-                } // if
-        }
-
-        void ConversionCost::visit( TupleType * tupleType ) {
+                        if ( type->base ) {
+                                cost = costFunc( type->base, dest, indexer, env ) + Cost::safe;
+                        } // if
+                } // if
+        }
+
+        void ConversionCost::postvisit( TupleType * tupleType ) {
                 Cost c = Cost::zero;
                 if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
-                        std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
-                        std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
-                        while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
-                                Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
+                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
+                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
+                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
+                                Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env );
                                 if ( newCost == Cost::infinity ) {
                                         return;
@@ -391 +391 @@
                                 c += newCost;
                         } // while
-                        if ( destIt != destAsTuple->get_types().end() ) {
+                        if ( destIt != destAsTuple->types.end() ) {
                                 cost = Cost::infinity;
                         } else {
@@ -399 +399 @@
         }
 
-        void ConversionCost::visit( VarArgsType * ) {
+        void ConversionCost::postvisit( VarArgsType * ) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -405 +405 @@
         }
 
-        void ConversionCost::visit( ZeroType * ) {
+        void ConversionCost::postvisit( ZeroType * ) {
                 if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::zero;
@@ -422 +422 @@
         }
 
-        void ConversionCost::visit( OneType * ) {
+        void ConversionCost::postvisit( OneType * ) {
                 if ( dynamic_cast< OneType * >( dest ) ) {
                         cost = Cost::zero;