Changeset e67a82d for src/ResolvExpr/ConversionCost.cc

Timestamp:

Aug 20, 2020, 11:48:15 PM (5 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

d685cb0

Parents:

67ca73e (diff), 013b028 (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:

fix conflicts

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -481 +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 ( eqv->bound ) {
-                                return conversionCost(src, eqv->bound, symtab, env );
+                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -508 +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;
                         }
                 }
@@ -518 +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 );
+                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                 src->accept( converter );
-                return converter.pass.cost;
-        }
-}
-
-static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
+                return converter.core.cost;
+        }
+}
+
+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;
@@ -538 +538 @@
                 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;
@@ -563 +563 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
                         src->accept( converter );
-                        return converter.pass.cost;
+                        return converter.core.cost;
                 }
         } else {
@@ -572 +572 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( src->is_lvalue() ) {
+                        if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -591 +591 @@
 
 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 );
 }
 
@@ -651 +651 @@
         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();
@@ -667 +667 @@
 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();
@@ -680 +680 @@
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
         if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
-                cost = costCalc( eqv->bound, dst, symtab, env );
+                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -690 +690 @@
                 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;
                 }
         }
@@ -703 +703 @@
                 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;
@@ -738 +738 @@
                         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 +759 @@
                         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