Changes in src/ResolvExpr/ConversionCost.cc [76fe046:748c751]

File:

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

src/ResolvExpr/ConversionCost.cc

@@ -278 +278 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } 
-        else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                auto enumDecl = enumInst->base;
-                if ( enumDecl->base.get() ) {
-                        // cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
-                        // cost.incUnsafe();
-                        cost = Cost::infinity;
-                } else {
-            cost = Cost::unsafe;
-                }
-        } else if ( dynamic_cast< const ast::EnumPosType *>(dst) ) {
+        } else if ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
                 cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
+        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
+                        cost = Cost::zero;
+                        cost.incUnsafe();
+                }
         }
 }
@@ -366 +361 @@
 }
 
-void ConversionCost::postvisit( const ast::EnumInstType * ) {
+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;
+                        }
+                }
+        } 
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
@@ -374 +377 @@
 }
 
-void ConversionCost::postvisit( const ast::EnumPosType * src ) {
-        if ( dynamic_cast<const ast::EnumPosType *>( dst ) ) {
-                // cost = costCalc( src->instance, dstBase->instance, srcIsLvalue, symtab, env );
-                // if ( cost < Cost::unsafe ) cost.incSafe();
-                cost = Cost::zero;
-        } else 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::BasicType::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::BasicType::SignedInt ) };
+                    cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+                    if ( cost < Cost::unsafe ) {
+                            cost.incSafe();
+                    }
+            }
+    }
 }
 
@@ -466 +478 @@
                 cost.incSafe( maxIntCost + 2 );
                 // assuming 0p is supposed to be used for pointers?
+        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
+                        cost = Cost::zero;
+                        cost.incUnsafe();
+                }
         }
 }
@@ -483 +500 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
+        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
+                        cost = Cost::zero;
+                        cost.incUnsafe();
+                }
         }
 }