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

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 );
-                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 ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, env ) ) {
                         if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
@@ -295 +284 @@
         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->isCfa ) {
-                        cost = Cost::safe;
+        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
+                        cost = Cost::unsafe;
                 }
         }
@@ -377 +366 @@
         if ( auto dstInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
                 cost = enumCastCost(inst, dstInst, symtab, env);
-        } 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();
+                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();
 }
 
@@ -459 +454 @@
                 // assuming 0p is supposed to be used for pointers?
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
-                        cost = Cost::safe;
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
+                        cost = Cost::unsafe;
                 }
         }
@@ -480 +475 @@
                 }
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
-                        cost = Cost::safe;
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
+                        cost = Cost::unsafe;
                 }
         }