Changeset eef8dfb for src/ResolvExpr/ConversionCost.cc

Timestamp:

Jan 7, 2021, 2:55:57 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

58fe85a

Parents:

bdfc032 (diff), 44e37ef (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 dkobets-vector

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 : Mon Aug 12 10:21:00 2019
-// Update Count     : 27
+// Last Modified On : Wed Jul 29 16:11:00 2020
+// Update Count     : 28
 //
 
@@ -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;
@@ -497 +481 @@
         }
 
-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 ); }
+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 ); }
+}
 
 Cost conversionCost(
-        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
-        const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+        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->name ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
                         if ( eqv->bound ) {
-                                return conversionCost(src, eqv->bound, symtab, env );
+                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -524 +508 @@
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
-                                return conversionCost( src, type->base, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
                         }
                 }
@@ -534 +518 @@
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
         } else {
-                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,
+                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,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                NumCostCalculation func ) {
+                PtrsCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
-                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
-                        dst, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
+                        srcIsLvalue, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -554 +536 @@
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
-                        (diff + 1), symtab, env, func );
+                        srcIsLvalue, (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -579 +561 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
-                        src->accept( converter );
-                        return converter.pass.cost;
+                        return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
                 }
         } else {
@@ -588 +568 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( src->is_lvalue() ) {
+                        if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -607 +587 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
-            const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                NumCostCalculation func ) {
+                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                PtrsCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
-        return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
 }
 
@@ -667 +647 @@
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
-        cost = costCalc( refType->base, dst, symtab, env );
+        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -681 +661 @@
 }
 
-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 const ast::BasicType integer( ast::BasicType::SignedInt );
-        cost = costCalc( &integer, dst, symtab, env );
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -713 +675 @@
 
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
-        if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
-                cost = costCalc( eqv->bound, dst, symtab, env );
+        if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
+                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
-                if ( typeInstType->name == dstAsInst->name ) {
+                if ( *typeInstType == *dstAsInst ) {
                         cost = Cost::zero;
                 }
@@ -724 +686 @@
                 assertf( type, "Unexpected typedef.");
                 if ( type->base ) {
-                        cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
                 }
         }
@@ -737 +699 @@
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
-                        Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;
@@ -772 +734 @@
                         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 );
         }
 }
@@ -789 +755 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
-                cost = Cost::zero;
-                cost.incSafe( maxIntCost + 2 );
-        }
-}
-
+        }
+}
+// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
 
 } // namespace ResolvExpr