Changeset c75b30a for src/ResolvExpr/CandidateFinder.cpp

Timestamp:

Jan 31, 2024, 6:25:02 PM (9 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.

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (3 diffs)

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 );
+                
         }