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

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 ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
+        } 
+        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) ) {
                 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();
-                }
         }
 }
@@ -361 +366 @@
 }
 
-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;
-                        }
-                }
-        } 
+void ConversionCost::postvisit( const ast::EnumInstType * ) {
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
@@ -377 +374 @@
 }
 
-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();
-                    }
-            }
-    }
+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();
+                }
+        }
+
 }
 
@@ -478 +466 @@
                 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();
-                }
         }
 }
@@ -500 +483 @@
                         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();
-                }
         }
 }