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

File:

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

src/ResolvExpr/ConversionCost.cpp

@@ -191 +191 @@
 }
 
+Cost enumCastCost (
+        const ast::EnumInstType * src, const ast::EnumInstType * dst, 
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+);
+
 static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
@@ -279 +284 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } else if ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
-                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
-        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
@@ -362 +364 @@
 
 void ConversionCost::postvisit( const ast::EnumInstType * inst ) {
-        if ( auto dstAsInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                if (inst->base && dstAsInst->base) {
-                        if (inst->base->name == dstAsInst->base->name) {
-                                cost = Cost::zero;
-                                return;
-                        }
-                }
+        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 ( cost < Cost::unsafe ) {
-                cost.incSafe();
-        }
-}
-
-void ConversionCost::postvisit( const ast::EnumAttrType * src ) {
-        auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
-        assert( src->attr != ast::EnumAttribute::Label );
-        if ( src->attr == ast::EnumAttribute::Value ) {
-                if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
-                        cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
-                } else {
-                        auto baseType = src->instance->base->base;
-                        cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::infinity ) {
-                                cost.incUnsafe();
-                        }
-                }
-        } else { // ast::EnumAttribute::Posn
-                if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                        cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::unsafe ) cost.incSafe();
-                } else {
-                        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::unsafe ) {
-                                cost.incSafe();
-                        }
-                }
-        }
+        if ( !inst->base->isTyped ) {
+                if ( cost < Cost::unsafe ) {
+                        cost.incSafe();
+                }
+                return;
+        }
+        cost.incUnsafe();
 }
 
@@ -507 +481 @@
 }
 
+// (dst) src is safe is src is a subtype of dst, or dst {inline src, ...}
+Cost enumCastCost (
+        const ast::EnumInstType * src, const ast::EnumInstType * dst, 
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+) {
+        auto srcDecl = src->base;
+        auto dstDecl = dst->base;
+        if (srcDecl->name == dstDecl->name) return Cost::safe;
+        Cost minCost = Cost::infinity;
+        for (auto child: dstDecl->inlinedDecl) {
+                Cost c = enumCastCost(src, child, symtab, env) + Cost::safe;
+                if (c<minCost) minCost = c;
+        }
+        return minCost;
+}
+
+
 // size_t ConversionCost::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");