Changeset a55ebcc

Timestamp:

Feb 5, 2024, 2:17:33 AM (3 months ago)

Author:

JiadaL <j82liang@…>

Branches:

master

Children:

47bd204

Parents:

020fa10

Message:

1. Add debug print option for replacePseudoFunc; 2. Change resolver handling enum types; 3. change QualifiedNameExpr? representation pre-resolver; 4. Disable able a test that currently doesn't work

Files:

• src/CompilationState.cc (modified) (1 diff)
• src/CompilationState.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• src/Validate/FixQualifiedTypes.cpp (modified) (1 diff)
• src/Validate/ReplacePseudoFunc.cpp (modified) (11 diffs)
• src/main.cc (modified) (2 diffs)
• tests/enum_tests/structEnum.cfa (modified) (1 diff)

src/CompilationState.cc

@@ -43 +43 @@
         codegenp = false,
         prettycodegenp = false,
-        linemarks = false;
+        linemarks = false,
+        reppseu = false;
 
 // Local Variables: //

src/CompilationState.h

@@ -42 +42 @@
         codegenp,
         prettycodegenp,
-        linemarks;
+        linemarks,
+        reppseu;
 
 // is the compiler building prelude or libcfa?

src/ResolvExpr/CandidateFinder.cpp

@@ -672 +672 @@
                 void postvisit( const ast::StmtExpr * stmtExpr );
                 void postvisit( const ast::UntypedInitExpr * initExpr );
+                void postvisit( const ast::QualifiedNameExpr * qualifiedExpr );
 
                 void postvisit( const ast::InitExpr * ) {
@@ -890 +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 >() ) {
+                } 
+                else if ( auto enumInst = aggrExpr->result.as< ast::EnumInstType >() ) {
                         // The Attribute Arrays are not yet generated, need to proxy them
                         // as attribute function call
@@ -1401 +1403 @@
         void Finder::postvisit( const ast::VariableExpr * variableExpr ) {
                 // 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( variableExpr, tenv );             
         }
 
@@ -1807 +1779 @@
         }
 
+        void Finder::postvisit( const ast::QualifiedNameExpr * expr ) {
+                std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( expr->name );
+                if ( declList.empty() ) return;
+
+                for ( ast::SymbolTable::IdData & data: declList ) {
+                        const ast::Type * t = data.id->get_type()->stripReferences();
+                        if ( const ast::EnumInstType * enumInstType =
+                                dynamic_cast<const ast::EnumInstType *>( t ) ) {
+                                if ( enumInstType->base->name == expr->type_decl->name ) {
+                                        Cost cost = Cost::zero;
+                                        ast::Expr * newExpr = data.combine( expr->location, cost );
+                                        CandidateRef newCand =
+                                                std::make_shared<Candidate>(
+                                                        newExpr, copy( tenv ), ast::OpenVarSet{}, 
+                                                        ast::AssertionSet{}, Cost::zero, cost
+                                                );
+                                        
+                                        if (newCand->expr->env) {
+                                                newCand->env.add(*newCand->expr->env);
+                                                auto mutExpr = newCand->expr.get_and_mutate();
+                                                mutExpr->env  = nullptr;
+                                                newCand->expr = mutExpr;
+                                        }
+
+                                        newCand->expr = ast::mutate_field(
+                                                newCand->expr.get(), &ast::Expr::result,
+                                                renameTyVars( newCand->expr->result ) );
+                                        addAnonConversions( newCand );
+                                        candidates.emplace_back( std::move( newCand ) );
+                                }
+                        }
+                }
+        }
         // size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder");
         /// Prunes a list of candidates down to those that have the minimum conversion cost for a given

src/Validate/FixQualifiedTypes.cpp

@@ -89 +89 @@
         }
 
-        ast::Expr const * postvisit( ast::QualifiedNameExpr const * t ) {
-                assert( location );
-                if ( !t->type_decl ) return t;
-
-                auto enumName = t->type_decl->name;
-                const ast::EnumDecl * enumDecl = symtab.lookupEnum( enumName );
-                for ( ast::ptr<ast::Decl> const & member : enumDecl->members ) {
-                        if ( auto memberAsObj = member.as<ast::ObjectDecl>() ) {
-                                if ( memberAsObj->name == t->name ) {
-                                        return new ast::VariableExpr( t->location, memberAsObj );
-                                }
-                        } else {
-                                assertf( false, "unhandled qualified child type" );
-                        }
-                }
-
-                auto var = new ast::ObjectDecl( t->location, t->name,
-                        new ast::EnumInstType( enumDecl, ast::CV::Const ),
-                        nullptr, {}, ast::Linkage::Cforall );
-                var->mangleName = Mangle::mangle( var );
-                return new ast::VariableExpr( t->location, var );
-        }
-
 };
 

src/Validate/ReplacePseudoFunc.cpp

@@ -9 +9 @@
 #include "Common/utility.h"
 #include "ResolvExpr/Resolver.h"
-#include "SymTab/Mangler.h"  // for Mangler
+#include "SymTab/Mangler.h"
+
+#include "AST/Print.hpp"
+
+#include "ResolvExpr/CandidateFinder.hpp"
+
 namespace Validate {
 
@@ -16 +21 @@
 std::set<std::string> queryLabels;
 std::set<std::string> queryValues;
+
+// struct AutoInit {
+//     ast::EnumDecl const* postvisit( const ast::EnumDecl* expr );
+// };
 
 struct WrapEnumValueExpr final : public ast::WithShortCircuiting,
@@ -23 +32 @@
     void previsit(const ast::ApplicationExpr* expr);
     void previsit(const ast::CastExpr* expr);
+    void previsit(const ast::VariableExpr* ) { visit_children = false; }
 
     ast::Expr const* postvisit(const ast::VariableExpr* expr);
@@ -33 +43 @@
 struct PseudoFuncGenerateRoutine final : public ast::WithDeclsToAdd<>,
                                          public ast::WithSymbolTable,
-                                         public ast::WithShortCircuiting {
+                                         public ast::WithShortCircuiting,
+                                         public ast::WithConstTranslationUnit {
     void previsit(const ast::EnumDecl* enumDecl);
 };
@@ -43 +54 @@
 };
 
+// ast::EnumDecl const * AutoInit::postvisit( const ast::EnumDecl * expr ) {
+//     for ( size_t i = 0; i < expr->members.size(); i++ ) {
+//         auto mem = expr->members[i].as<ast::ObjectDecl>();
+//         assert( mem );
+//         if ( mem->init )
+//     }
+//     return expr;
+// }
+
 void WrapEnumValueExpr::previsit(const ast::ApplicationExpr* expr) {
-
     auto varExpr = expr->func.as<ast::VariableExpr>();
     auto fname = ast::getFunctionName(expr);
@@ -52 +71 @@
         }
 
-    if (fname == "labelE" || fname == "valueE" || fname == "posE")
+    if (fname == "labelE" || fname == "valueE" || fname == "posE") {
         visit_children = false;
+    }
 }
 
@@ -67 +87 @@
 
 ast::Expr const* WrapEnumValueExpr::postvisit(const ast::VariableExpr* expr) {
-    visit_children = false;
     if (!expr->result) {
         return expr;
@@ -75 +94 @@
             auto untyped = new ast::UntypedExpr(
                 expr->location, new ast::NameExpr(expr->location, "valueE"),
-                {new ast::VariableExpr(*expr)});
+                { std::move( expr ) });
             ResolvExpr::ResolveContext context{symtab, transUnit().global};
             auto result = ResolvExpr::findVoidExpression(untyped, context);
-            if (result.get()) {
-                ast::ptr<ast::ApplicationExpr> ret =
+            ast::ptr<ast::ApplicationExpr> ret =
                     result.strict_as<ast::ApplicationExpr>();
-                return new ast::ApplicationExpr(*ret);
-            }
+            return ast::deepCopy( ret );
         }
     }
@@ -115 +132 @@
 }
 
+const ast::Init * getAutoInit( const CodeLocation & location,
+    const ast::Type * type, ResolvExpr::ResolveContext context, const ast::Init * prev ) {
+    if ( auto prevInit = dynamic_cast< const ast::SingleInit * >( prev ) ) {
+        auto prevInitExpr = prevInit->value;
+        if ( auto constInit = prevInitExpr.as< ast::ConstantExpr >() ) {
+            // Assume no string literal for now
+            return new ast::SingleInit(
+                location,
+                ast::ConstantExpr::from_int(
+                    location, constInit->intValue() + 1 )
+            );
+        } else {
+            auto untypedThisInit = new ast::UntypedExpr(
+                    location,
+                    new ast::NameExpr( location, "?++" ),
+                    { prevInitExpr }
+                );
+            auto typedInit = ResolvExpr::findSingleExpression(untypedThisInit, type,
+                context );
+            return new ast::SingleInit( location, typedInit );
+        }
+    }
+    SemanticError( prev, "Auto Init a List is not implemented" );
+    return prev;
+}
+
 void PseudoFuncGenerateRoutine::previsit(const ast::EnumDecl* enumDecl) {
     visit_children = false;
@@ -122 +165 @@
     std::vector<ast::ptr<ast::Init>> inits;
     std::vector<ast::ptr<ast::Init>> labels;
-    for (const ast::Decl* mem : enumDecl->members) {
-        auto memAsObjectDecl = dynamic_cast<const ast::ObjectDecl*>(mem);
-        inits.emplace_back(memAsObjectDecl->init);
+    auto type = enumDecl->base;
+
+    for ( size_t i = 0; i < enumDecl->members.size(); i++ ) {
+        ast::ptr<ast::Decl> mem = enumDecl->members.at( i );
+        auto memAsObjectDecl = mem.as< ast::ObjectDecl >();
+        assert( memAsObjectDecl );
+        if ( memAsObjectDecl->init ) {
+            inits.emplace_back( memAsObjectDecl->init );
+        } else {
+            const CodeLocation & location = mem->location;
+            if ( i == 0 ) {
+                inits.emplace_back( new ast::SingleInit( 
+                    location, 
+                    ast::ConstantExpr::from_int( mem->location, 0 )
+                ) );
+            } else {
+                inits.emplace_back( getAutoInit( location, enumDecl->base, 
+                    ResolvExpr::ResolveContext{symtab, transUnit().global}, 
+                    inits.at( i - 1 ).as<ast::SingleInit>()) );
+            }
+        }
         labels.emplace_back(new ast::SingleInit(
-            location, ast::ConstantExpr::from_string(location, mem->name)));
-    }
+        location, ast::ConstantExpr::from_string(location, mem->name)));
+    } 
     if (queryValues.count(enumDecl->name)) {
         auto init = new ast::ListInit(location, std::move(inits));
@@ -206 +267 @@
                     return ast::ConstantExpr::from_string(expr->location,
                                                           referredName);
-                else
+                else {
                     return getPseudoFuncApplication(location, context, arg.get(),
-                                               base, "values_");
+                                               base, "values_");                    
+                }
+
             }
         }

src/main.cc

@@ -383 +383 @@
                 DUMP( exprp, std::move( transUnit ) );
                 PASS( "Replace Pseudo Func", Validate::replacePseudoFunc, transUnit );
-
+                DUMP( reppseu, std::move( transUnit ) );
                 PASS( "Fix Init", InitTweak::fix, transUnit, buildingLibrary() );
                 PASS( "Erase With", ResolvExpr::eraseWith, transUnit );
@@ -536 +536 @@
         { "bbox", bboxp, true, "print AST before box pass" },
         { "bcodegen", bcodegenp, true, "print AST before code generation" },
+        { "reppseu", reppseu, true, "print AST after replacing pseudo functions" }
 };
 enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };

tests/enum_tests/structEnum.cfa

@@ -17 +17 @@
 };
 
-PointEnum foo(PointEnum in) {
-     return in;
-}
+// PointEnum foo(PointEnum in) {
+//      return in;
+// }
 
 // The only valid usage