Changes in src/ResolvExpr/ConversionCost.cc [3e5dd913:849720f]

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 29 16:11:00 2020
-// Update Count     : 28
+// Last Modified On : Mon Aug 12 10:21:00 2019
+// Update Count     : 27
 //
 
@@ -392 +392 @@
         void ConversionCost::postvisit( const FunctionType * ) {}
 
+        void ConversionCost::postvisit( const StructInstType * inst ) {
+                if ( const StructInstType * destAsInst = dynamic_cast< const StructInstType * >( dest ) ) {
+                        if ( inst->name == destAsInst->name ) {
+                                cost = Cost::zero;
+                        } // if
+                } // if
+        }
+
+        void ConversionCost::postvisit( const UnionInstType * inst ) {
+                if ( const UnionInstType * destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) {
+                        if ( inst->name == destAsInst->name ) {
+                                cost = Cost::zero;
+                        } // if
+                } // if
+        }
+
         void ConversionCost::postvisit( const EnumInstType * ) {
                 static Type::Qualifiers q;
@@ -481 +497 @@
         }
 
-namespace {
-        # warning For overload resolution between the two versions.
-        int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
-                        const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
-                return ptrsAssignable( t1, t2, env );
-        }
-        Cost localConversionCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-        ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
-}
+static int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
+                const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
+        return ptrsAssignable( t1, t2, env );
+}
+
+// TODO: This is used for overload resolution. It might be able to be dropped once the old system
+// is removed.
+static Cost localConversionCost(
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
+) { return conversionCost( src, dst, symtab, env ); }
 
 Cost conversionCost(
-        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
-                if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
                         if ( eqv->bound ) {
-                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
+                                return conversionCost(src, eqv->bound, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -508 +524 @@
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
-                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, symtab, env ) + Cost::safe;
                         }
                 }
@@ -518 +534 @@
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
         } else {
-                return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
-        }
-}
-
-static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                src->accept( converter );
+                return converter.pass.cost;
+        }
+}
+
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+                NumCostCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
-                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
-                        srcIsLvalue, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
+                        dst, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -536 +554 @@
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
-                        srcIsLvalue, (diff + 1), symtab, env, func );
+                        (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -561 +579 @@
                         }
                 } else {
-                        return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
+                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                        src->accept( converter );
+                        return converter.pass.cost;
                 }
         } else {
@@ -568 +588 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( srcIsLvalue ) {
+                        if ( src->is_lvalue() ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -587 +607 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
-                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+            const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                NumCostCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
-        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
 }
 
@@ -647 +667 @@
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
-        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
+        cost = costCalc( refType->base, dst, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -661 +681 @@
 }
 
+void ConversionCost_new::postvisit( const ast::StructInstType * structInstType ) {
+        if ( const ast::StructInstType * dstAsInst =
+                        dynamic_cast< const ast::StructInstType * >( dst ) ) {
+                if ( structInstType->name == dstAsInst->name ) {
+                        cost = Cost::zero;
+                }
+        }
+}
+
+void ConversionCost_new::postvisit( const ast::UnionInstType * unionInstType ) {
+        if ( const ast::UnionInstType * dstAsInst =
+                        dynamic_cast< const ast::UnionInstType * >( dst ) ) {
+                if ( unionInstType->name == dstAsInst->name ) {
+                        cost = Cost::zero;
+                }
+        }
+}
+
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        static const ast::BasicType integer( ast::BasicType::SignedInt );
+        cost = costCalc( &integer, dst, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -675 +713 @@
 
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
-        if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
-                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
+        if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
+                cost = costCalc( eqv->bound, dst, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
-                if ( *typeInstType == *dstAsInst ) {
+                if ( typeInstType->name == dstAsInst->name ) {
                         cost = Cost::zero;
                 }
@@ -686 +724 @@
                 assertf( type, "Unexpected typedef.");
                 if ( type->base ) {
-                        cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
                 }
         }
@@ -699 +737 @@
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
-                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;
@@ -734 +772 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
-                cost = Cost::zero;
-                // +1 for zero_t ->, +1 for disambiguation
-                cost.incSafe( maxIntCost + 2 );
         }
 }
@@ -755 +789 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        }
-}
-// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
+        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
+                cost = Cost::zero;
+                cost.incSafe( maxIntCost + 2 );
+        }
+}
+
 
 } // namespace ResolvExpr