Changeset c75b30a for src/ResolvExpr

Timestamp:

Jan 31, 2024, 6:25:02 PM (5 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

32490deb

Parents:

16afb2a

Message:

Introduce posE, valueE, labelE pseudo language to the language. Rework the internal representation of enumeration.

Location:

src/ResolvExpr

Files:

• CandidateFinder.cpp (modified) (3 diffs)
• ConversionCost.cc (modified) (2 diffs)
• Unify.cc (modified) (1 diff)

src/ResolvExpr/CandidateFinder.cpp

@@ -891 +891 @@
                 } else if ( auto unionInst = aggrExpr->result.as< ast::UnionInstType >() ) {
                         addAggMembers( unionInst, aggrExpr, *cand, Cost::unsafe, "" );
+                } else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
+                        // The Attribute Arrays are not yet generated, need to proxy them
+                        // as attribute function call
+                        const CodeLocation & location = cand->expr->location;
+                        if ( enumInst->base && enumInst->base->base ) {
+                                auto valueName = new ast::NameExpr(location, "valueE");
+                                auto untypedValueCall = new ast::UntypedExpr( 
+                                        location, valueName, { aggrExpr } );
+                                auto result = ResolvExpr::findVoidExpression( untypedValueCall, context );
+                                assert( result.get() );
+                                CandidateRef newCand = std::make_shared<Candidate>(
+                                        *cand, result, Cost::safe );
+                                candidates.emplace_back( std::move( newCand ) );
+                        }
                 }
         }
@@ -961 +975 @@
 
                                         if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);                                             
-                                        // else if (const ast::EnumInstType * enumInst = argType.as<ast::EnumInstType>()) {
-                                        //      const ast::EnumDecl * enumDecl = enumInst->base; // Here
-                                        //      if ( const ast::Type* enumType = enumDecl->base ) {
-                                        //              // instance of enum (T) is a instance of type (T)
-                                        //              funcFinder.otypeKeys.insert(Mangle::mangle(enumType, Mangle::NoGenericParams | Mangle::Type));
-                                        //      } else {
-                                        //              // instance of an untyped enum is techically int
-                                        //              funcFinder.otypeKeys.insert(Mangle::mangle(enumDecl, Mangle::NoGenericParams | Mangle::Type));
-                                        //      }
-                                        // }
                                         else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
                                 }
@@ -1399 +1403 @@
                 // not sufficient to just pass `variableExpr` here, type might have changed since
                 // creation
-                addCandidate(
-                        new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
+                if ( auto obj =  dynamic_cast<const ast::ObjectDecl *>( variableExpr->var.get() )) {
+                        if ( auto enumInstType = dynamic_cast<const ast::EnumInstType *>( obj->type.get() ) ) {
+                                if ( enumInstType->base && enumInstType->base->base ) {
+                                        const CodeLocation & location = variableExpr->location;
+                                        auto ids = symtab.lookupId( "valueE" );
+                                                for ( ast::SymbolTable::IdData & id : ids ) {
+                                                        if ( auto func = id.id.as<ast::FunctionDecl>() ) {
+                                                                if ( func->params.size() == 1 ) {
+                                                                        ast::ptr<ast::DeclWithType> valueEParam = func->params.front();
+                                                                        auto valueEParamType = valueEParam->get_type();
+                                                                        ast::OpenVarSet funcOpen;
+                                                                        ast::AssertionSet funcNeed, funcHave;
+                                                                        ast::TypeEnvironment funcEnv{ tenv };
+                                                                        ast::ptr<ast::Type> common;
+                                                                        if ( unifyInexact( valueEParamType, enumInstType, funcEnv, funcNeed, funcHave, funcOpen, WidenMode{ true, true }, common ) ) {
+                                                                                auto appl = new ast::ApplicationExpr( location,
+                                                                                        ast::VariableExpr::functionPointer( location,  func), { variableExpr } );
+                                                                                // addCandidate( appl, copy( tenv ),  );
+                                                                                Candidate cand {appl, copy( tenv )};
+                                                                                addCandidate( cand, appl, Cost::safe );
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                }
+                        
+                        }
+                } 
+                addCandidate( variableExpr, tenv );
+                
         }
 

src/ResolvExpr/ConversionCost.cc

@@ -279 +279 @@
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
-                const ast::EnumDecl * enumDecl = enumInst->base.get();
-                if ( enumDecl->isTyped && !enumDecl->base.get() ) {
-                        cost = Cost::infinity;
-                } else if ( const ast::Type * enumType = enumDecl->base.get() ) {
-                        if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
-                                conversionCostFromBasicToBasic( basicType, enumTypeAsBasic );
-                        } else {
-                                cost = Cost::infinity;
-                        }
+                auto enumDecl = enumInst->base;
+                if ( auto baseType = enumDecl->base.get() ) {
+                        cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
+                        cost.incUnsafe();
                 } else {
             cost = Cost::unsafe;
@@ -367 +362 @@
 
 void ConversionCost::postvisit( const ast::EnumInstType * enumInstType ) {
-        const ast::EnumDecl * baseEnum = enumInstType->base;
-        if ( const ast::Type * baseType = baseEnum->base ) {
-                costCalc( baseType, dst, srcIsLvalue, symtab, env );
-        } else {
-                static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-                cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
-        }
+        //      const ast::EnumDecl * baseEnum = enumInstType->base;
+        // if ( const ast::Type * baseType = baseEnum->base ) {
+        //      costCalc( baseType, dst, srcIsLvalue, symtab, env );
+        // } else {
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        // }
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();

src/ResolvExpr/Unify.cc

@@ -73 +73 @@
                 ast::Type * newFirst  = shallowCopy( first  );
                 ast::Type * newSecond = shallowCopy( second );
-                if ( auto temp = dynamic_cast<const ast::EnumInstType *>(first) ) {
-                        if ( !dynamic_cast< const ast::EnumInstType * >( second ) ) {
-                                const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-                                if ( auto t = baseEnum->base.get() ) {
-                                        newFirst = ast::shallowCopy( t );
-                                }
-                        }
-                } else if ( auto temp = dynamic_cast<const ast::EnumInstType *>(second) ) {
-                        const ast::EnumDecl * baseEnum = dynamic_cast<const ast::EnumDecl *>(temp->base.get());
-                        if ( auto t = baseEnum->base.get() ) {
-                                newSecond = ast::shallowCopy( t );
-                        }
-                }
 
                 newFirst ->qualifiers = {};