Changeset acb33f15 for src/ResolvExpr

Timestamp:

May 13, 2024, 10:26:52 AM (12 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

31f4837

Parents:

41c8312

Message:

Change enum conversion steps

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (6 diffs)
• CommonType.cc (modified) (2 diffs)
• ConversionCost.cc (modified) (2 diffs)
• ConversionCost.h (modified) (1 diff)
• Unify.cc (modified) (8 diffs)

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -906 +906 @@
                                 }
                                 CandidateRef & choice = winners.front();
-                                choice->cost.incSafe();
+                                choice->cost = Cost::unsafe;
                                 candidates.emplace_back( std::move(choice) );
                         }
@@ -955 +955 @@
 
                 CandidateFinder funcFinder( context, tenv );
+                std::string funcName;
                 if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
+                        funcName = nameExpr->name;
                         auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
                         if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
@@ -1019 +1021 @@
                 CandidateList found;
                 SemanticErrorException errors;
+                
                 for ( CandidateRef & func : funcFinder ) {
                         try {
@@ -1093 +1096 @@
                         Cost cvtCost = computeApplicationConversionCost( withFunc, symtab );
 
+                        if (funcName == "?|?") {
                         PRINT(
                                 auto appExpr = withFunc->expr.strict_as< ast::ApplicationExpr >();
@@ -1108 +1112 @@
                                 std::cerr << "cost of conversion is:" << cvtCost << std::endl;
                         )
-
+                        }
                         if ( cvtCost != Cost::infinity ) {
                                 withFunc->cvtCost = cvtCost;
@@ -1774 +1778 @@
                                                 matches.clear();
                                         }
-                                        // ambiguous case, still output candidates to print in error message
-                                        if ( cand->cost == minExprCost && thisCost == minCastCost ) {
-                                                auto commonAsEnumAttr = common.as<ast::EnumAttrType>();
-                                                if ( commonAsEnumAttr && commonAsEnumAttr->attr == ast::EnumAttribute::Value ) {
-                                                        auto callExpr = new ast::UntypedExpr(
-                                                                cand->expr->location, new ast::NameExpr( cand->expr->location, "valueE"), {cand->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();
-                                                        // assert( valueCall->result );
-                                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                                new ast::InitExpr{
-                                                                        initExpr->location,
-                                                                        // restructureCast( cand->expr, toType ),
-                                                                        choice->expr,
-                                                                        initAlt.designation },
-                                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
-                                                                inferParameters( newCand, matches );
-                                                } else {
-                                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                                new ast::InitExpr{
-                                                                        initExpr->location,
-                                                                        restructureCast( cand->expr, toType ),
-                                                                        initAlt.designation },
-                                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
-                                                        // currently assertions are always resolved immediately so this should have no effect.
-                                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
-                                                        // we may need to revisit the logic.
-                                                        inferParameters( newCand, matches );
-                                                }
-                                        }
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                new ast::InitExpr{
+                                                        initExpr->location,
+                                                        restructureCast( cand->expr, toType ),
+                                                        initAlt.designation },
+                                                std::move(env), std::move( open ), std::move( need ), cand->cost + thisCost );
+                                        // currently assertions are always resolved immediately so this should have no effect.
+                                        // if this somehow changes in the future (e.g. delayed by indeterminate return type)
+                                        // we may need to revisit the logic.
+                                        inferParameters( newCand, matches );
                                 }
                         }

src/ResolvExpr/CommonType.cc ¶

@@ -388 +388 @@
                         const ast::EnumDecl* enumDecl = enumInst->base;
                         if ( !enumDecl->base ) {
-                                ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
-                                if (
-                                        ( ( kind == basic->kind && basic->qualifiers >= type2->qualifiers )
-                                                || widen.first )
-                                        && ( ( kind != basic->kind && basic->qualifiers <= type2->qualifiers )
-                                                || widen.second )
-                                ) {
-                                        result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
-                                }
-                        }
-                } else if ( auto type2AsAttr = dynamic_cast< const ast::EnumAttrType * >( type2 ) ) {
-                        if ( type2AsAttr->attr == ast::EnumAttribute::Posn ) {
                                 ast::BasicKind kind = commonTypes[ basic->kind ][ ast::BasicKind::SignedInt ];
                                 if (
@@ -656 +644 @@
         }
 
-        void postvisit( const ast::EnumAttrType * ) {}
-
         void postvisit( const ast::TraitInstType * ) {}
 

src/ResolvExpr/ConversionCost.cc ¶

@@ -279 +279 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } else if ( dynamic_cast< const ast::EnumAttrType *>(dst) ) {
-                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-                cost = costCalc( basicType, integer, srcIsLvalue, symtab, env );
-        } else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        }       else if ( auto dstAsEnumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 if ( dstAsEnumInst->base && !dstAsEnumInst->base->isTyped ) {
                         cost = Cost::unsafe;
@@ -373 +370 @@
         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();
-        }
-}
-
-void ConversionCost::postvisit( const ast::EnumAttrType * src ) {
-        auto dstAsEnumAttrType = dynamic_cast<const ast::EnumAttrType *>(dst);
-        assert( src->attr != ast::EnumAttribute::Label );
-        if ( src->attr == ast::EnumAttribute::Value ) {
-                if ( dstAsEnumAttrType && dstAsEnumAttrType->attr == ast::EnumAttribute::Value) {
-                        cost = costCalc( src->instance, dstAsEnumAttrType->instance, srcIsLvalue, symtab, env );
-                } else {
-                        auto baseType = src->instance->base->base;
-                        cost = costCalc( baseType, dst, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::infinity ) {
-                                cost.incUnsafe();
-                        }
-                }
-        } else { // ast::EnumAttribute::Posn
-                if ( auto dstBase = dynamic_cast<const ast::EnumInstType *>( dst ) ) {
-                        cost = costCalc( src->instance, dstBase, srcIsLvalue, symtab, env );
-                        if ( cost < Cost::unsafe ) cost.incSafe();
-                } else {
-                        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();
-                        }
-                }
-        }
+        if ( !inst->base->isTyped ) {
+                if ( cost < Cost::unsafe ) {
+                        cost.incSafe();
+                }
+                return;
+        }
+        cost.incUnsafe();
 }
 

src/ResolvExpr/ConversionCost.h ¶

@@ -72 +72 @@
         void postvisit( const ast::ZeroType * zeroType );
         void postvisit( const ast::OneType * oneType );
-        void postvisit( const ast::EnumAttrType * posType );
 private:
         // refactor for code resue

src/ResolvExpr/Unify.cc ¶

@@ -275 +275 @@
 
         void postvisit( const ast::VoidType * vt) {
-                result = dynamic_cast< const ast::VoidType * >( type2 )
-                        || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
+                result = dynamic_cast< const ast::VoidType * >( type2 ); 
+                        // || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
                 ;
         }
@@ -284 +284 @@
                         result = basic->kind == basic2->kind;
                 }
-                result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
+                // result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
         }
 
@@ -293 +293 @@
                                 noWiden());
                 }
-                result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
+                // result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
         }
 
@@ -311 +311 @@
 
                 result = unifyExact(
-                        array->base, array2->base, tenv, need, have, open, noWiden())
-                        || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
+                        array->base, array2->base, tenv, need, have, open, noWiden());
+                        // || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
         }
 
@@ -404 +404 @@
         }
 
-        bool tryToUnifyWithEnumValue( const ast::Type * type1, const ast::Type * type2, ast::TypeEnvironment & env,
-                ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
-                WidenMode widen) {
-                if ( auto attrType2 = dynamic_cast<const ast::EnumAttrType *>(type2)) {
-                        if (attrType2->attr == ast::EnumAttribute::Value) {
-                                return unifyExact( type1, attrType2->instance->base->base, env, need, have, open,
-                                        widen);
-                        } else if (attrType2->attr == ast::EnumAttribute::Posn) {
-                                return unifyExact( type1, attrType2->instance, env, need, have, open, widen );
-                        }
-                }
-                return false;
-        }
-
 public:
         void postvisit( const ast::FunctionType * func ) {
@@ -527 +513 @@
         void postvisit( const ast::StructInstType * aggrType ) {
                 handleGenericRefType( aggrType, type2 );
-                result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::UnionInstType * aggrType ) {
                 handleGenericRefType( aggrType, type2 );
-                result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::EnumInstType * aggrType ) {
                 handleRefType( aggrType, type2 );
-                result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
-        }
-
-        void postvisit( const ast::EnumAttrType * enumAttr ) {
-                // Lazy approach for now
-                if ( auto otherPos = dynamic_cast< const ast::EnumAttrType *>( type2 ) ) {
-                        if ( enumAttr->match(otherPos) ) {
-                                result = otherPos;
-                        }
-                }
         }
 
         void postvisit( const ast::TraitInstType * aggrType ) {
                 handleRefType( aggrType, type2 );
-                result = result || tryToUnifyWithEnumValue(aggrType, type2, tenv, need, have, open, noWiden());
         }
 
@@ -560 +533 @@
                         this->result = otherInst;
                 }
-                result = result || tryToUnifyWithEnumValue(typeInst, type2, tenv, need, have, open, noWiden());
         }
 
@@ -634 +606 @@
                 auto types2 = flatten( flat2 );
 
-                result = unifyList( types, types2, tenv, need, have, open )
-                        || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
+                result = unifyList( types, types2, tenv, need, have, open );
+                        // || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::VarArgsType * vat) {
-                result = dynamic_cast< const ast::VarArgsType * >( type2 )
-                        || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
+                result = dynamic_cast< const ast::VarArgsType * >( type2 );
+                        // || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::ZeroType * zt) {
-                result = dynamic_cast< const ast::ZeroType * >( type2 )
-                        || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
+                result = dynamic_cast< const ast::ZeroType * >( type2 );
+                        // || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::OneType * ot) {
-                result = dynamic_cast< const ast::OneType * >( type2 )
-                        || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
+                result = dynamic_cast< const ast::OneType * >( type2 );
+                        // || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
         }
 };