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

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,
@@ -284 +279 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        } 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 ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
@@ -364 +362 @@
 
 void ConversionCost::postvisit( const ast::EnumInstType * inst ) {
-        if ( auto dstInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                cost = enumCastCost(inst, dstInst, symtab, env);
+        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;
+                        }
+                }
                 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();
+        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();
+                        }
+                }
+        }
 }
 
@@ -481 +507 @@
 }
 
-// (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");