Changeset 5ccc733

Timestamp:

Jun 29, 2024, 5:02:06 AM (3 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

Files:

• AST/Decl.cpp (modified) (1 diff)
• AST/Decl.hpp (modified) (2 diffs)
• ControlStruct/TranslateEnumRange.cpp (modified) (1 diff)
• Parser/TypeData.cpp (modified) (1 diff)
• ResolvExpr/CastCost.cpp (modified) (4 diffs)
• ResolvExpr/CommonType.cpp (modified) (2 diffs)
• ResolvExpr/ConversionCost.cpp (modified) (5 diffs)
• Validate/ImplementEnumFunc.cpp (modified) (1 diff)

src/AST/Decl.cpp

@@ -203 +203 @@
 }
 
+bool EnumDecl::isTyped() const { return base;}
+
+bool EnumDecl::isOpague() const { return isCfa && !isTyped(); } 
 }
 

src/AST/Decl.hpp

@@ -308 +308 @@
 class EnumDecl final : public AggregateDecl {
 public:
-        // isTyped indicated if the enum has a declaration like:
+        // isCfa indicated if the enum has a declaration like:
         // enum (type_optional) Name {...}
-        bool isTyped;
-        // if isTyped == true && base.get() == nullptr, it is a "void" type enum
+        bool isCfa;
+        // if isCfa == true && base.get() == nullptr, it is a "opague" enum
         ptr<Type> base;
         enum class EnumHiding { Visible, Hide } hide;
         std::vector< ast::ptr<ast::EnumInstType>> inlinedDecl; // child enums
 
-        EnumDecl( const CodeLocation& loc, const std::string& name, bool isTyped = false,
+        EnumDecl( const CodeLocation& loc, const std::string& name, bool isCfa = false,
                 std::vector<ptr<Attribute>>&& attrs = {}, Linkage::Spec linkage = Linkage::Cforall,
                 Type const * base = nullptr, EnumHiding hide = EnumHiding::Hide,
                 std::unordered_map< std::string, long long > enumValues = std::unordered_map< std::string, long long >() )
-        : AggregateDecl( loc, name, std::move(attrs), linkage ), isTyped(isTyped), base(base), hide(hide), enumValues(enumValues) {}
+        : AggregateDecl( loc, name, std::move(attrs), linkage ), isCfa(isCfa), base(base), hide(hide), enumValues(enumValues) {}
 
         /// gets the integer value for this enumerator, returning true iff value found
@@ -336 +336 @@
 
         bool isSubTypeOf(const ast::EnumDecl *) const;
+        bool isTyped() const;
+        bool isOpague() const;
 private:
         EnumDecl * clone() const override { return new EnumDecl{ *this }; }

src/ControlStruct/TranslateEnumRange.cpp

@@ -91 +91 @@
     ast::UntypedExpr * condition = ast::UntypedExpr::createCall( location,
         "?<=?",
-        { 
-            ast::UntypedExpr::createCall(location, "posn", { new ast::NameExpr( location, indexName ) } ),
-            ast::ConstantExpr::from_ulong( location, enumDecl->members.size()-1 )
-        });
+        {new ast::CastExpr(location,
+            new ast::NameExpr( location, indexName ),
+            new ast::BasicType( ast::BasicKind::UnsignedInt ),
+            ast::GeneratedFlag::ExplicitCast),
+        ast::ConstantExpr::from_ulong( location, enumDecl->members.size()-1 ) });
+
     auto increment = ast::UntypedExpr::createCall( location, 
-        stmt->is_inc? "succ": "pred",
+        stmt->is_inc? "?++": "?--",
         { new ast::NameExpr( location, indexName ) });
+    
     auto assig = ast::UntypedExpr::createAssign( location, new ast::NameExpr( location, indexName ), increment );
     auto mut = ast::mutate_field( stmt, &ast::ForStmt::cond, condition );

src/Parser/TypeData.cpp

@@ -1469 +1469 @@
                 ast::ObjectDecl * object = strict_dynamic_cast<ast::ObjectDecl *>( member );
                 object->isHidden = ast::EnumDecl::EnumHiding::Hide == ret->hide;
-                if ( ret->isTyped && !ret->base && cur->has_enumeratorValue() ) {
-                        SemanticError( td->location, "Enumerator of enum(void) cannot have an explicit initializer value." );
+                if ( ret->isOpague() && cur->has_enumeratorValue() ) {
+                        SemanticError( td->location, "Opague cannot have an explicit initializer value." );
                 } else if ( cur->has_enumeratorValue() ) {
                         object->init = new ast::SingleInit(

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;
                 }
         }

src/Validate/ImplementEnumFunc.cpp

@@ -476 +476 @@
 
 void ImplementEnumFunc::previsit(const ast::EnumDecl* enumDecl) {
-        if (!enumDecl->body || !enumDecl->isTyped) return;
+        if (!enumDecl->body || !enumDecl->isCfa) return;
         ast::EnumInstType enumInst(enumDecl->name);
         enumInst.base = enumDecl;