Changeset 0522ebe for src/ResolvExpr

Timestamp:

Feb 26, 2024, 3:49:23 AM (4 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

a4da45e

Parents:

c17dc80

Message:

Add EnumPosType? to type system

Location:

src/ResolvExpr

Files:

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

src/ResolvExpr/CandidateFinder.cpp

@@ -893 +893 @@
                 } 
                 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 ) );
-                        }
+                        if (enumInst->base && enumInst->base->base) {
+            const CodeLocation &location = cand->expr->location;
+
+            CandidateFinder funcFinder(context, tenv);
+            auto nameExpr = new ast::NameExpr(location, "valueE");
+            ResolveMode mode = {true, false, selfFinder.candidates.empty()};
+            funcFinder.find( nameExpr, mode );
+
+            // make variableExpr itself the candidate for the value Call
+            ExplodedArgs argExpansions;
+            argExpansions.emplace_back();
+            auto &argE = argExpansions.back();
+
+            argE.emplace_back(*cand, symtab); // Use the typed name expr as param for value
+
+            CandidateList found;
+            SemanticErrorException errors;
+
+            for (CandidateRef &func : funcFinder) {
+                try {
+                    const ast::Type *funcResult =
+                        func->expr->result->stripReferences();
+                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
+                            funcResult)) {
+                        if (auto function =
+                                pointer->base.as<ast::FunctionType>()) {
+                            CandidateRef newFunc{new Candidate{*func}};
+                            newFunc->expr = referenceToRvalueConversion(
+                                newFunc->expr, newFunc->cost);
+                            makeFunctionCandidates( location,
+                                                   newFunc, function,
+                                                   argExpansions, found );
+                        }
+                    }
+                } catch (SemanticErrorException &e) {
+                    std::cerr
+                        << "Resolving value function should cause an error"
+                        << std::endl;
+                    errors.append(e);
+                }
+            }
+
+            if (found.empty()) {
+                std::cerr << "Resolve value function should always success"
+                          << std::endl;
+            }
+
+            for (CandidateRef &withFunc : found) {
+                withFunc->cost.incSafe();
+                Cost cvtCost =
+                    computeApplicationConversionCost(withFunc, symtab);
+                assert(cvtCost != Cost::infinity);
+
+                candidates.emplace_back(std::move(withFunc));
+            }
+        }
                 }
         }
@@ -1401 +1444 @@
         }
 
-        void Finder::postvisit( const ast::VariableExpr * variableExpr ) {
-                // not sufficient to just pass `variableExpr` here, type might have changed since
-                addCandidate( variableExpr, tenv );             
-        }
+    void Finder::postvisit(const ast::VariableExpr *variableExpr) {
+        // not sufficient to just pass `variableExpr` here, type might have changed
+
+        auto cand = new Candidate(variableExpr, tenv);
+        candidates.emplace_back(cand);
+
+        if (auto enumInst = dynamic_cast<const ast::EnumInstType *>(
+                variableExpr->var->get_type())) {
+            if (enumInst->base && enumInst->base->base) {
+                const CodeLocation &location = cand->expr->location;
+
+                CandidateFinder funcFinder(context, tenv);
+                auto nameExpr = new ast::NameExpr(location, "valueE");
+                ResolveMode mode = {true, false, selfFinder.candidates.empty()};
+                funcFinder.find( nameExpr, mode );
+
+                // make variableExpr itself the candidate for the value Call
+                ExplodedArgs argExpansions;
+                argExpansions.emplace_back();
+                auto &argE = argExpansions.back();
+
+                argE.emplace_back(*cand, symtab);
+
+                CandidateList found;
+                SemanticErrorException errors;
+
+                for (CandidateRef &func : funcFinder) {
+                    try {
+                    const ast::Type *funcResult =
+                        func->expr->result->stripReferences();
+                    if (auto pointer = dynamic_cast<const ast::PointerType *>(
+                            funcResult)) {
+                        if (auto function =
+                                pointer->base.as<ast::FunctionType>()) {
+                            CandidateRef newFunc{new Candidate{*func}};
+                            newFunc->expr = referenceToRvalueConversion(
+                                newFunc->expr, newFunc->cost);
+                            makeFunctionCandidates(variableExpr->location,
+                                                   newFunc, function,
+                                                   argExpansions, found);
+                        }
+                    }
+                    } catch (SemanticErrorException &e) {
+                        std::cerr
+                            << "Resolving value function should cause an error"
+                            << std::endl;
+                        errors.append(e);
+                    }
+                }
+
+                if (found.empty()) {
+                    std::cerr << "Resolve value function should always success"
+                            << std::endl;
+                }
+
+                for (CandidateRef &withFunc : found) {
+                    withFunc->cost.incSafe();
+                    Cost cvtCost =
+                        computeApplicationConversionCost(withFunc, symtab);
+                    assert(cvtCost != Cost::infinity);
+
+                    candidates.emplace_back(std::move(withFunc));
+                }
+            }
+        }
+    }
 
         void Finder::postvisit( const ast::ConstantExpr * constantExpr ) {

src/ResolvExpr/CommonType.cc

@@ -397 +397 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | type2->qualifiers };
                                 }
+                        }
+                } else if ( const ast::EnumPosType * pos = dynamic_cast< const ast::EnumPosType * >( type2 ) ) {
+                        ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::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 };
                         }
                 }

src/ResolvExpr/ConversionCost.cc

@@ -278 +278 @@
         if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
                 conversionCostFromBasicToBasic( basicType, dstAsBasic );
-        } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
+        } 
+        else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( dst ) ) {
                 auto enumDecl = enumInst->base;
-                if ( auto baseType = enumDecl->base.get() ) {
-                        cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
-                        cost.incUnsafe();
+                if ( enumDecl->base.get() ) {
+                        // cost = costCalc( basicType, baseType, srcIsLvalue, symtab, env );
+                        // cost.incUnsafe();
+                        cost = Cost::infinity;
                 } else {
             cost = Cost::unsafe;
@@ -365 +367 @@
         cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         // }
+        if ( cost < Cost::unsafe ) {
+                cost.incSafe();
+        }
+}
+
+void ConversionCost::postvisit( const ast::EnumPosType * ) {
+        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/ConversionCost.h

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

src/ResolvExpr/Unify.cc

@@ -517 +517 @@
                 }
 
+                void postvisit( const ast::EnumPosType * posType ) {
+                        // Does nothing for now. Handled in ReplacePseudoFunc
+                        // Might move here in the future
+                }
+
                 void postvisit( const ast::TraitInstType * aggrType ) {
                         handleRefType( aggrType, type2 );