Changeset 90e683b for src/ResolvExpr

Timestamp:

Feb 3, 2025, 11:46:55 AM (2 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

54f70c6

Parents:

bbbff10

Message:

I set out to do a enum rework. It ended up being much the same and I unwound the core rework. But I hope the new names are a bit clearer and other minor fixes are helpful, so I am keeping those.

Location:

src/ResolvExpr

Files:

• CastCost.cpp (modified) (1 diff)
• CommonType.cpp (modified) (2 diffs)
• ConversionCost.cpp (modified) (8 diffs)
• ResolveTypeof.cpp (modified) (2 diffs)

src/ResolvExpr/CastCost.cpp ¶

@@ -53 +53 @@
                 void postvisit( const ast::EnumInstType * enumInst ) {
                         cost = conversionCost( enumInst, dst, srcIsLvalue, symtab, env );
-                        if ( enumInst->base->isTyped() ) {
-                                auto baseConversionCost = 
+                        if ( enumInst->base->is_typed_enum() ) {
+                                auto baseConversionCost =
                                         castCost( enumInst->base->base, dst, srcIsLvalue, symtab, env );
-                                cost = baseConversionCost < cost? baseConversionCost: cost;
+                                cost = baseConversionCost < cost ? baseConversionCost : cost;
                         }
                         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
                         Cost intCost = costCalc( integer, dst, srcIsLvalue, symtab, env );
                         intCost.incSafe();
-                        cost = intCost < cost? intCost: cost;
+                        cost = intCost < cost ? intCost : cost;
                 }
 

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->isCfa  ) {
+                        if ( enumDecl->is_c_enum() ) {
                                 ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
                                 if (
@@ -654 +654 @@
                                 result = param;
                         }
-                } else if ( param->base && !param->base->isCfa ) {
+                } else if ( param->base && param->base->is_c_enum() ) {
                         auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );
                         result = commonType( basicType, type2, tenv, need, have, open, widen);

src/ResolvExpr/ConversionCost.cpp ¶

@@ -246 +246 @@
                 }
                 if (const ast::EnumInstType * srcAsInst = dynamic_cast< const ast::EnumInstType * >( src )) {
-                        if (srcAsInst->base && !srcAsInst->base->isCfa) {
+                        if ( srcAsInst->base && srcAsInst->base->is_c_enum() ) {
                                 static const ast::BasicType* integer = new ast::BasicType( ast::BasicKind::UnsignedInt );
                                 return ast::Pass<ConversionCost>::read( integer, dst, srcIsLvalue, symtab, env, conversionCost );
@@ -324 +324 @@
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                if ( dstAsEnumInst->base && dstAsEnumInst->base->is_c_enum() ) {
                         cost = Cost::safe;
                 }
@@ -405 +405 @@
         if ( auto dstInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
                 cost = enumCastCost(inst, dstInst, symtab, env);
-        } else if ( !inst->base->isCfa ) {
+        } else if ( inst->base->is_c_enum() ) {
                 static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
                 cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
@@ -455 +455 @@
 }
 
-void ConversionCost::postvisit( const ast::VarArgsType * varArgsType ) {
-        (void)varArgsType;
+void ConversionCost::postvisit( const ast::VarArgsType * ) {
         if ( dynamic_cast< const ast::VarArgsType * >( dst ) ) {
                 cost = Cost::zero;
@@ -462 +461 @@
 }
 
-void ConversionCost::postvisit( const ast::ZeroType * zeroType ) {
-        (void)zeroType;
+void ConversionCost::postvisit( const ast::ZeroType * ) {
         if ( dynamic_cast< const ast::ZeroType * >( dst ) ) {
                 cost = Cost::zero;
@@ -487 +485 @@
                 // assuming 0p is supposed to be used for pointers?
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                if ( dstAsEnumInst->base && dstAsEnumInst->base->is_c_enum() ) {
                         cost = Cost::safe;
                 }
@@ -493 +491 @@
 }
 
-void ConversionCost::postvisit( const ast::OneType * oneType ) {
-        (void)oneType;
+void ConversionCost::postvisit( const ast::OneType * ) {
         if ( dynamic_cast< const ast::OneType * >( dst ) ) {
                 cost = Cost::zero;
@@ -508 +505 @@
                 }
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isCfa ) {
+                if ( dstAsEnumInst->base && dstAsEnumInst->base->is_c_enum() ) {
                         cost = Cost::safe;
                 }

src/ResolvExpr/ResolveTypeof.cpp ¶

@@ -62 +62 @@
                         // replace basetypeof(<enum>) by int
                         auto enumInst = newType.as< ast::EnumInstType >();
-                        if ( enumInst && (!enumInst->base || !enumInst->base->isCfa) ) {
+                        if ( enumInst && (!enumInst->base || enumInst->base->is_c_enum() ) ) {
                                 newType = new ast::BasicType(
                                         ast::BasicKind::SignedInt, newType->qualifiers, copy(newType->attributes) );
@@ -144 +144 @@
 
         auto enumInst = decl->type.as<ast::EnumInstType>();
-        if ( enumInst && enumInst->base->isCfa ) {
+        if ( enumInst && !enumInst->base->is_c_enum() ) {
                 if ( auto init = decl->init.as<ast::SingleInit>() ) {
                         if ( auto initExpr = init->value.as<ast::ConstantExpr>() ) {
                                 if ( initExpr->result.as<ast::ZeroType>() ) {
-                                        auto newInit = new ast::SingleInit( init->location, 
+                                        auto newInit = new ast::SingleInit( init->location,
                                                 ast::UntypedExpr::createCall( init->location, "lowerBound", {} )
                                         );