Changeset 5ccc733 for src/ResolvExpr

Timestamp:

Jun 29, 2024, 5:02:06 AM (7 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

4117761

Parents:

7552fde

Message:

Fix the bug that C style enum cannot to use as an lvalue

Location:

src/ResolvExpr

Files:

• CastCost.cpp (modified) (4 diffs)
• CommonType.cpp (modified) (2 diffs)
• ConversionCost.cpp (modified) (5 diffs)

src/ResolvExpr/CastCost.cpp

@@ -54 +54 @@
                         cost = conversionCost( enumInst, dst, srcIsLvalue, symtab, env );
 
-                        if (Cost::unsafe < cost) {
+                        if ( !enumInst->base->isCfa ) {
                                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
                                 Cost intCost = costCalc( integer, dst, srcIsLvalue, symtab, env );
                                 cost = intCost < cost? intCost: cost;
-                        }
-                        if ( enumInst->base->isTyped && enumInst->base->base ) {
+                        } else if ( enumInst->base->isTyped() ) {
                                 auto baseConversionCost = 
                                         castCost( enumInst->base->base, dst, srcIsLvalue, symtab, env );
@@ -74 +73 @@
                                 cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
                                 if ( Cost::unsafe < cost ) {
-                                        if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                                // Always explict cast only for typed enum
-                                                if (enumInst->base->isTyped) cost = Cost::unsafe;
+                                        if ( dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                                cost = Cost::unsafe;
                                         }
                                 }
@@ -85 +83 @@
                         cost = conversionCost( zero, dst, srcIsLvalue, symtab, env );
                         if ( Cost::unsafe < cost ) {
-                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        if (enumInst->base->isTyped) cost = Cost::unsafe;
+                                if ( dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                        cost = Cost::unsafe;
                                 }
                         }
@@ -94 +92 @@
                         cost = conversionCost( one, dst, srcIsLvalue, symtab, env );
                         if ( Cost::unsafe < cost ) {
-                                if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        if (enumInst->base->isTyped) cost = Cost::unsafe;
+                                if ( dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                        cost = Cost::unsafe;
                                 }
                         }

src/ResolvExpr/CommonType.cpp

@@ -386 +386 @@
                 } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
                         const ast::EnumDecl* enumDecl = enumInst->base;
-                        if ( !enumDecl->base ) {
+                        if ( !enumDecl->isCfa  ) {
                                 ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
                                 if (
@@ -642 +642 @@
                         const ast::EnumDecl* argDecl = argAsEnumInst->base;
                         if (argDecl->isSubTypeOf(paramDecl)) result = param;
-                } else if ( param->base && !param->base->isTyped ) {
+                } else if ( param->base && !param->base->isCfa ) {
                         auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );
                         result = commonType( basicType, type2, tenv, need, have, open, widen);

src/ResolvExpr/ConversionCost.cpp

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