Changeset cdb4eaa

Timestamp:

Apr 17, 2024, 2:27:56 PM (7 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

748c751

Parents:

76c7addb

Message:

Fix succ(Enum) error and resolution ambiguity of enum with inheritance

Location:

src

Files:

• ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• main.cc (modified) (2 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -513 +513 @@
                                         // add new result
                                         assert( common );
-                                        // auto attrType = common.as<ast::EnumAttrType>();
-                                        // if ( attrType && ( attrType->attr == ast::EnumAttribute::Value ) ) {
-                                        //      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();
-                                        //      choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-
-                                        //      results.emplace_back(
-                                        //              i, choice->expr, 
-                                        //              std::move( env ), std::move( need ), std::move( have ), std::move( open ),
-                                        //              nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
-                                        // } else {
                                                 results.emplace_back(
                                                         i, expr, std::move( env ), std::move( need ), std::move( have ), std::move( open ),
@@ -921 +903 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if (winners.size() != 1) {
-                                        SemanticError( callExpr, "Ambiguous expression in valueE" );
+                                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
                                 }
                                 CandidateRef & choice = winners.front();
-                                // choice->cost.incSafe();
+                                choice->cost.incVar();
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -1801 +1783 @@
                                                         CandidateList winners = findMinCost( finder.candidates );
                                                         if (winners.size() != 1) {
-                                                                SemanticError( callExpr, "Ambiguous expression in valueE" );
+                                                                SemanticError( callExpr, "Ambiguous expression in valueE..." );
                                                         }
                                                         CandidateRef & choice = winners.front();
@@ -2161 +2143 @@
                 CandidateList winners = findMinCost( finder.candidates );
                 if (winners.size() != 1) {
-                        SemanticError( callExpr, "Ambiguous expression in valueE" );
+                        SemanticError( callExpr, "Ambiguous expression in valueE..." );
                 }
                 CandidateRef & choice = winners.front();

src/ResolvExpr/ConversionCost.cc

@@ -362 +362 @@
 
 void ConversionCost::postvisit( const ast::EnumInstType * inst ) {
-        if ( inst->base && inst->base->base ) {
-                if ( auto dstAsAttr = dynamic_cast<const ast::EnumAttrType *>( dst ) ) {
-                        auto instAsAttr = ast::EnumAttrType( inst, dstAsAttr->attr );
-                        if ( instAsAttr.match(dstAsAttr) ) {
-                                cost.incUnsafe();
-                        }
-
-                } else if ( auto dstAsInst = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                        if (inst->base && dstAsInst->base) {
-                                if (inst->base == dstAsInst->base) {
-                                        cost.incUnsafe();
-                                }
-                        }
-                } else {
-                        auto instAsVal = ast::EnumAttrType( inst, ast::EnumAttribute::Value );
-                        cost = costCalc( &instAsVal, dst, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::infinity ) {
-                                cost.incUnsafe();
-                        }
-                }
-                return;
+        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;
+                        }
+                }
         } 
         static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };

src/main.cc

@@ -382 +382 @@
                 DUMP( exprp, std::move( transUnit ) );
                 PASS( "Replace Pseudo Func", Validate::replacePseudoFunc, transUnit );
-                DUMP( reppseu, std::move( transUnit ) );
                 PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() ); // Here
                 PASS( "Erase With", ResolvExpr::eraseWith, transUnit );
@@ -534 +533 @@
         { "instgen", genericsp, true, "print AST after instantiate generics" },
         { "bbox", bboxp, true, "print AST before box pass" },
-        { "bcodegen", bcodegenp, true, "print AST before code generation" },
-        { "reppseu", reppseu, true, "print AST after replacing pseudo functions" }
+        { "bcodegen", bcodegenp, true, "print AST before code generation" }
 };
 enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };