Changes in src/ResolvExpr/ConversionCost.cpp [85855b0:5ccc733]

File:

• src/ResolvExpr/ConversionCost.cpp (modified) (6 diffs)

src/ResolvExpr/ConversionCost.cpp

@@ -162 +162 @@
 Cost conversionCost(
         const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -235 +235 @@
                         return ast::Pass<ConversionCost>::read( src, dst, srcIsLvalue, symtab, env, conversionCost );
                 }
+                if (const ast::EnumInstType * srcAsInst = dynamic_cast< const ast::EnumInstType * >( src )) {
+                        if (srcAsInst->base && !srcAsInst->base->isCfa) {
+                                static const ast::BasicType* integer = new ast::BasicType( ast::BasicKind::UnsignedInt );
+                                return ast::Pass<ConversionCost>::read( integer, dst, srcIsLvalue, symtab, env, conversionCost );
+                        }
+                }
         } else {
                 assert( -1 == diff );
                 const ast::ReferenceType * dstAsRef = dynamic_cast< const ast::ReferenceType * >( dst );
                 assert( dstAsRef );
-                if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, env ) ) {
+                auto dstBaseType = dstAsRef->base;
+                const ast::Type * newSrc = src;
+                if ( dynamic_cast< const ast::EnumInstType * >( src ) && dstBaseType.as<ast::BasicType>() ) {
+                        newSrc = new ast::BasicType( ast::BasicKind::UnsignedInt );
+                }
+                if ( typesCompatibleIgnoreQualifiers( newSrc, dstAsRef->base, env ) ) {
                         if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
@@ -284 +295 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
-                        cost = Cost::unsafe;
+        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                        cost = Cost::safe;
                 }
         }
@@ -366 +377 @@
         if ( auto dstInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
                 cost = enumCastCost(inst, dstInst, symtab, env);
-                return;
-        }
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-        if ( !inst->base->isTyped ) {
-                if ( cost < Cost::unsafe ) {
-                        cost.incSafe();
-                }
-                return;
-        }
-        cost.incUnsafe();
+        } else if ( !inst->base->isCfa ) {
+                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
+                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        }
+        // cost.incUnsafe();
 }
 
@@ -454 +459 @@
                 // assuming 0p is supposed to be used for pointers?
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
-                        cost = Cost::unsafe;
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                        cost = Cost::safe;
                 }
         }
@@ -475 +480 @@
                 }
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
-                        cost = Cost::unsafe;
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                        cost = Cost::safe;
                 }
         }