Changeset d3aa55e9 for src/ResolvExpr

Timestamp:

Jun 27, 2024, 4:42:01 PM (8 weeks ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

7552fde

Parents:

d5efcb7

Message:

1. Disallow implicit conversion from cfa enum to int during on the function call site; 2. implement the reverse enum loop

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (4 diffs)
• CastCost.cpp (modified) (1 diff)
• ConversionCost.cpp (modified) (4 diffs)
• Unify.cpp (modified) (5 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -698 +698 @@
                 void postvisit( const ast::CountExpr * countExpr );
 
-                const ast::Expr * makeEnumOffsetCast( const ast::EnumInstType * src, 
-                        const ast::EnumInstType * dst
-                        , const ast::Expr * expr, Cost minCost );
-
                 void postvisit( const ast::InitExpr * ) {
                         assertf( false, "CandidateFinder should never see a resolved InitExpr." );
@@ -1213 +1209 @@
         }
 
-        // src is a subset of dst
-        const ast::Expr * Finder::makeEnumOffsetCast( const ast::EnumInstType * src, 
-                const ast::EnumInstType * dst,
-                const ast::Expr * expr,
-                Cost minCost ) {
-                
-                auto srcDecl = src->base;
-                auto dstDecl = dst->base;
-
-                if (srcDecl->name == dstDecl->name) return expr;
-
-                for (auto& dstChild: dstDecl->inlinedDecl) {
-                        Cost c = castCost(src, dstChild, false, symtab, tenv);
-                        ast::CastExpr * castToDst;
-                        if (c<minCost) {
-                                unsigned offset = dstDecl->calChildOffset(dstChild.get());
-                                if (offset > 0) {
-                                        auto untyped = ast::UntypedExpr::createCall(
-                                                expr->location, 
-                                                "?+?", 
-                                                { new ast::CastExpr( expr, new ast::BasicType(ast::BasicKind::SignedInt) ),
-                                                ast::ConstantExpr::from_int(expr->location, offset)});
-                                        CandidateFinder finder(context, tenv);
-                                        finder.find( untyped );
-                                        CandidateList winners = findMinCost( finder.candidates );
-                                        CandidateRef & choice = winners.front();
-                                        // choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
-                                        choice->expr = new ast::CastExpr(expr->location, choice->expr, dstChild, ast::GeneratedFlag::ExplicitCast);
-                                        // castToDst = new ast::CastExpr(choice->expr, dstChild);
-                                        castToDst = new ast::CastExpr( 
-                                                makeEnumOffsetCast( src, dstChild, choice->expr, minCost ),
-                                         dst);
-
-                                } else {
-                                        castToDst = new ast::CastExpr( expr, dst );
-                                }
-                                return castToDst;
-                        }
-                }
-                SemanticError(expr, src->base->name + " is not a subtype of " + dst->base->name);
-                return nullptr;
-        }
-
         void Finder::postvisit( const ast::CastExpr * castExpr ) {
                 ast::ptr< ast::Type > toType = castExpr->result;
@@ -1309 +1262 @@
                         auto argAsEnum = cand->expr->result.as<ast::EnumInstType>();
                         auto toAsEnum = toType.as<ast::EnumInstType>();
-                        if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {     
-                                ast::ptr<ast::Expr> offsetExpr = makeEnumOffsetCast(argAsEnum, toAsEnum, cand->expr, thisCost);
+                        if ( argAsEnum && toAsEnum && argAsEnum->name != toAsEnum->name ) {
+                                CandidateFinder subFinder(context, tenv);
+                                ast::ptr<ast::Expr> offsetExpr = subFinder.makeEnumOffsetCast(argAsEnum, toAsEnum, cand->expr, thisCost);
                                 cand->expr = offsetExpr;
                         }
@@ -2193 +2147 @@
                                         expr->location, 
                                         "?+?", 
-                                        { new ast::CastExpr( expr, new ast::BasicType(ast::BasicKind::SignedInt) ),
-                                        ast::ConstantExpr::from_int(expr->location, offset)});
+                                        { new ast::CastExpr( expr->location,
+                                                expr,
+                                                new ast::BasicType(ast::BasicKind::SignedInt),
+                                                ast::GeneratedFlag::ExplicitCast ),
+                                                ast::ConstantExpr::from_int(expr->location, offset)} );
                                 CandidateFinder finder(context, env);
                                 finder.find( untyped );

src/ResolvExpr/CastCost.cpp

@@ -53 +53 @@
                 void postvisit( const ast::EnumInstType * enumInst ) {
                         cost = conversionCost( enumInst, dst, srcIsLvalue, symtab, env );
+
+                        if (Cost::unsafe < cost) {
+                                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 ) {
+                                auto baseConversionCost = 
+                                        castCost( enumInst->base->base, dst, srcIsLvalue, symtab, env );
+                                cost = baseConversionCost < cost? baseConversionCost: cost;
+                        }
                 }
 

src/ResolvExpr/ConversionCost.cpp

@@ -162 +162 @@
 Cost conversionCost(
         const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -284 +284 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        }       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;
@@ -368 +368 @@
                 return;
         }
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicKind::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+
         if ( !inst->base->isTyped ) {
+                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();
@@ -376 +377 @@
                 return;
         }
-        cost.incUnsafe();
+        // cost.incUnsafe();
 }
 

src/ResolvExpr/Unify.cpp

@@ -276 +276 @@
         void postvisit( const ast::VoidType * ) {
                 result = dynamic_cast< const ast::VoidType * >( type2 );
-                        // || tryToUnifyWithEnumValue(vt, type2, tenv, need, have, open, noWiden());
-                ;
         }
 
@@ -284 +282 @@
                         result = basic->kind == basic2->kind;
                 }
-                // result = result || tryToUnifyWithEnumValue(basic, type2, tenv, need, have, open, noWiden());
         }
 
@@ -293 +290 @@
                                 noWiden());
                 }
-                // result = result || tryToUnifyWithEnumValue(pointer, type2, tenv, need, have, open, noWiden());
         }
 
@@ -312 +308 @@
                 result = unifyExact(
                         array->base, array2->base, tenv, need, have, open, noWiden());
-                        // || tryToUnifyWithEnumValue(array, type2, tenv, need, have, open, noWiden());
         }
 
@@ -607 +602 @@
 
                 result = unifyList( types, types2, tenv, need, have, open );
-                        // || tryToUnifyWithEnumValue(tuple, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::VarArgsType * ) {
                 result = dynamic_cast< const ast::VarArgsType * >( type2 );
-                        // || tryToUnifyWithEnumValue(vat, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::ZeroType * ) {
                 result = dynamic_cast< const ast::ZeroType * >( type2 );
-                        // || tryToUnifyWithEnumValue(zt, type2, tenv, need, have, open, noWiden());
         }
 
         void postvisit( const ast::OneType * ) {
                 result = dynamic_cast< const ast::OneType * >( type2 );
-                        // || tryToUnifyWithEnumValue(ot, type2, tenv, need, have, open, noWiden());
         }
 };