Changes in src/ResolvExpr/CandidateFinder.cpp [c75b30a:61e362f]

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 ) );
-                        }
                 }
         }
@@ -975 +961 @@
 
                                         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));
                                 }
@@ -1403 +1399 @@
                 // not sufficient to just pass `variableExpr` here, type might have changed since
                 // creation
-                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 );
-                
+                addCandidate(
+                        new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
         }