Changeset c333ed2 for src/ResolvExpr

Timestamp:

May 7, 2024, 7:04:17 PM (2 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

0b6c1c9

Parents:

164a6b6

Message:

Remove intermeidate type (enum attribute type); remove replacePseudoFunc (has been migrated to resolver)

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (1 diff)
• CandidateFinder.hpp (modified) (1 diff)
• CastCost.cc (modified) (2 diffs)
• CommonType.cc (modified) (1 diff)
• ConversionCost.cc (modified) (3 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -2138 +2138 @@
 }
 
-// get the valueE(...) ApplicationExpr that returns the enum value
-const ast::Expr * getValueEnumCall(
-        const ast::Expr * expr,
-        const ResolvExpr::ResolveContext & context, const ast::TypeEnvironment & env ) {
-                auto callExpr = new ast::UntypedExpr(
-                        expr->location, new ast::NameExpr( expr->location, "valueE"), {expr} );
-                CandidateFinder finder( context, env );
-                finder.find( callExpr );
-                CandidateList winners = findMinCost( finder.candidates );
-                if (winners.size() != 1) {
-                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
-                }
-                CandidateRef & choice = winners.front();
-                return choice->expr;
-}
-
 const ast::Expr * createCondExpr( const ast::Expr * expr ) {
         assert( expr );

src/ResolvExpr/CandidateFinder.hpp

@@ -70 +70 @@
         const ast::Expr * expr, Cost & cost );
 
-/// Get the valueE application that returns the enum's value.
-const ast::Expr * getValueEnumCall( const ast::Expr * expr,
-        const ResolveContext & context, const ast::TypeEnvironment & env );
-
 /// Wrap an expression to convert the result to a conditional result.
 const ast::Expr * createCondExpr( const ast::Expr * expr );

src/ResolvExpr/CastCost.cc

@@ -54 +54 @@
                                 cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
                                 if ( Cost::unsafe < cost ) {
-                                        if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                                assert(enumInst->base->base);
-                                                cost = Cost::unsafe;
+                                        if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                                // Always explict cast only for typed enum
+                                                if (enumInst->base->isTyped) cost = Cost::unsafe;
                                         }
                                 }
@@ -63 +63 @@
 
                 void postvisit( const ast::ZeroType * zero ) {
-                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
-                        // if ( ptr && basicType->isInteger() ) {
-                        //      // needed for, e.g. unsigned long => void *
-                        //      cost = Cost::unsafe;
-                        // } else {
                         cost = conversionCost( zero, dst, srcIsLvalue, symtab, env );
                         if ( Cost::unsafe < cost ) {
                                 if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        assert(enumInst->base->base);
-                                        cost = Cost::unsafe;
+                                        if (enumInst->base->isTyped) cost = Cost::unsafe;
                                 }
                         }
-                        // }
                 }
 
                 void postvisit( const ast::OneType * one ) {
-                        // auto ptr = dynamic_cast< const ast::PointerType * >( dst );
-                        // if ( ptr && basicType->isInteger() ) {
-                        //      // needed for, e.g. unsigned long => void *
-                        //      cost = Cost::unsafe;
-                        // } else {
                         cost = conversionCost( one, dst, srcIsLvalue, symtab, env );
                         if ( Cost::unsafe < cost ) {
-                                if (auto enumInst =  dynamic_cast<const ast::EnumInstType *>(dst)) {
-                                        assert(enumInst->base->base);
-                                        cost = Cost::unsafe;
+                                if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(dst)) {
+                                        if (enumInst->base->isTyped) cost = Cost::unsafe;
                                 }
                         }
-                        // }
                 }
 

src/ResolvExpr/CommonType.cc

@@ -650 +650 @@
 
         void postvisit( const ast::EnumInstType * enumInst ) {
-                if ( enumInst->base && !enumInst->base->base ) {
+                if ( enumInst->base && !enumInst->base->isTyped ) {
                         auto basicType = new ast::BasicType( ast::BasicKind::UnsignedInt );
                         result = commonType( basicType, type2, tenv, need, have, open, widen);

src/ResolvExpr/ConversionCost.cc

@@ -283 +283 @@
                 cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
                 }
@@ -480 +480 @@
                 // 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 ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
                 }
@@ -501 +501 @@
                 }
         } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                if ( dstAsEnumInst->base && !dstAsEnumInst->base->base ) {
+                if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
                 }