Changeset a55ebcc for src/Validate

Timestamp:

Feb 5, 2024, 2:17:33 AM (4 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

Location:

src/Validate

Files:

• FixQualifiedTypes.cpp (modified) (1 diff)
• ReplacePseudoFunc.cpp (modified) (11 diffs)

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