Improve class_constructor.cpp pass and StructTypeConstructor node in ASR

src/libasr/ASR.asdl

@@ -224,7 +224,7 @@ expr
     | NamedExpr(expr target, expr value, ttype type)
     | FunctionCall(symbol name, symbol? original_name, call_arg* args,
             ttype type, expr? value, expr? dt)
-    | StructTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value)
+    | StructTypeConstructor(symbol dt_sym, call_arg* args, ttype type, expr? value)
     | EnumTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value)
     | UnionTypeConstructor(symbol dt_sym, expr* args, ttype type, expr? value)
     | ImpliedDoLoop(expr* values, expr var, expr start, expr end,

src/libasr/codegen/asr_to_llvm.cpp

@@ -5563,8 +5563,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 break;
             }
             case ASR::ttypeType::Struct: {
-                ASR::Struct_t* der = (ASR::Struct_t*)(&(x->m_type->base));
-                ASR::StructType_t* der_type = (ASR::StructType_t*)(&(der->m_derived_type->base));
+                ASR::Struct_t* der = ASR::down_cast<ASR::Struct_t>(x->m_type);
+                ASR::StructType_t* der_type = ASR::down_cast<ASR::StructType_t>(
+                    ASRUtils::symbol_get_past_external(der->m_derived_type));
                 der_type_name = std::string(der_type->m_name);
                 uint32_t h = get_hash((ASR::asr_t*)x);
                 if( llvm_symtab.find(h) != llvm_symtab.end() ) {
@@ -5584,8 +5585,9 @@ class ASRToLLVMVisitor : public ASR::BaseVisitor<ASRToLLVMVisitor>
                 break;
             }
             case ASR::ttypeType::Class: {
-                ASR::Class_t* der = (ASR::Class_t*)(&(x->m_type->base));
-                ASR::ClassType_t* der_type = (ASR::ClassType_t*)(&(der->m_class_type->base));
+                ASR::Class_t* der = ASR::down_cast<ASR::Class_t>(x->m_type);
+                ASR::ClassType_t* der_type = ASR::down_cast<ASR::ClassType_t>(
+                    ASRUtils::symbol_get_past_external(der->m_class_type));
                 der_type_name = std::string(der_type->m_name);
                 uint32_t h = get_hash((ASR::asr_t*)x);
                 if( llvm_symtab.find(h) != llvm_symtab.end() ) {

src/libasr/pass/class_constructor.cpp

@@ -3,91 +3,225 @@
 #include <libasr/exception.h>
 #include <libasr/asr_utils.h>
 #include <libasr/asr_verify.h>
-#include <libasr/pass/pass_utils.h>
 #include <libasr/pass/class_constructor.h>
+#include <libasr/pass/pass_utils.h>
 
-#include <cstring>
-
+#include <vector>
+#include <utility>
+#include <queue>
 
 namespace LCompilers {
 
 using ASR::down_cast;
 using ASR::is_a;
 
-class ClassConstructorVisitor : public PassUtils::PassVisitor<ClassConstructorVisitor>
-{
-private:
+class ReplaceStructTypeConstructor: public ASR::BaseExprReplacer<ReplaceStructTypeConstructor> {
+
+    private:
+
+    Allocator& al;
+    Vec<ASR::stmt_t*>& pass_result;
+    bool& remove_original_statement;
+    bool& inside_symtab;
+    std::map<SymbolTable*, Vec<ASR::stmt_t*>>& symtab2decls;
+
+    public:
+
+    SymbolTable* current_scope;
     ASR::expr_t* result_var;
 
-public:
+    ReplaceStructTypeConstructor(Allocator& al_, Vec<ASR::stmt_t*>& pass_result_,
+        bool& remove_original_statement_, bool& inside_symtab_,
+        std::map<SymbolTable*, Vec<ASR::stmt_t*>>& symtab2decls_) :
+    al(al_), pass_result(pass_result_),
+    remove_original_statement(remove_original_statement_),
+    inside_symtab(inside_symtab_), symtab2decls(symtab2decls_),
+    current_scope(nullptr), result_var(nullptr) {}
 
-    bool is_constructor_present;
+    void replace_StructTypeConstructor(ASR::StructTypeConstructor_t* x) {
+        if( x->n_args == 0 ) {
+            remove_original_statement = true;
+            return ;
+        }
+        if( result_var == nullptr ) {
+            std::string result_var_name = current_scope->get_unique_name("temp_struct_var__");
+            result_var = PassUtils::create_auxiliary_variable(x->base.base.loc,
+                                result_var_name, al, current_scope, x->m_type);
+            *current_expr = result_var;
+        } else {
+            if( inside_symtab ) {
+                *current_expr = nullptr;
+            } else {
+                remove_original_statement = true;
+            }
+        }
 
-    ClassConstructorVisitor(Allocator &al) : PassVisitor(al, nullptr),
-    result_var(nullptr), is_constructor_present(false) {
-        pass_result.reserve(al, 0);
-    }
+        std::deque<ASR::symbol_t*> constructor_arg_syms;
+        ASR::Struct_t* dt_der = ASR::down_cast<ASR::Struct_t>(x->m_type);
+        ASR::StructType_t* dt_dertype = ASR::down_cast<ASR::StructType_t>(
+                                         ASRUtils::symbol_get_past_external(dt_der->m_derived_type));
+        while( dt_dertype ) {
+            for( int i = (int) dt_dertype->n_members - 1; i >= 0; i-- ) {
+                constructor_arg_syms.push_front(
+                    dt_dertype->m_symtab->get_symbol(
+                        dt_dertype->m_members[i]));
+            }
+            if( dt_dertype->m_parent != nullptr ) {
+                ASR::symbol_t* dt_der_sym = ASRUtils::symbol_get_past_external(
+                                        dt_dertype->m_parent);
+                LCOMPILERS_ASSERT(ASR::is_a<ASR::StructType_t>(*dt_der_sym));
+                dt_dertype = ASR::down_cast<ASR::StructType_t>(dt_der_sym);
+            } else {
+                dt_dertype = nullptr;
+            }
+        }
+        LCOMPILERS_ASSERT(constructor_arg_syms.size() == x->n_args);
 
-    void visit_Assignment(const ASR::Assignment_t& x) {
-        ASR::Assignment_t& xx = const_cast<ASR::Assignment_t&>(x);
-        if( x.m_value->type == ASR::exprType::StructTypeConstructor ) {
-            is_constructor_present = true;
-            if( x.m_overloaded == nullptr ) {
-                result_var = x.m_target;
-                visit_expr(*x.m_value);
+        for( size_t i = 0; i < x->n_args; i++ ) {
+            if( x->m_args[i].m_value == nullptr ) {
+                 continue ;
+            }
+            ASR::symbol_t* member = constructor_arg_syms[i];
+            if( ASR::is_a<ASR::StructTypeConstructor_t>(*x->m_args[i].m_value) ) {
+                ASR::expr_t* result_var_copy = result_var;
+                ASR::symbol_t *v = nullptr;
+                if (ASR::is_a<ASR::Var_t>(*result_var_copy)) {
+                    v = ASR::down_cast<ASR::Var_t>(result_var_copy)->m_v;
+                }
+                result_var = ASRUtils::EXPR(ASRUtils::getStructInstanceMember_t(al,
+                                            x->base.base.loc, (ASR::asr_t*) result_var_copy, v,
+                                            member, current_scope));
+                ASR::expr_t** current_expr_copy = current_expr;
+                current_expr = &(x->m_args[i].m_value);
+                replace_expr(x->m_args[i].m_value);
+                current_expr = current_expr_copy;
+                result_var = result_var_copy;
             } else {
-                std::string result_var_name = current_scope->get_unique_name("temp_struct_var__");
-                result_var = PassUtils::create_auxiliary_variable(x.m_value->base.loc, result_var_name,
-                                al, current_scope, ASRUtils::expr_type(x.m_target));
-                visit_expr(*x.m_value);
-                ASR::stmt_t* x_m_overloaded = x.m_overloaded;
-                if( ASR::is_a<ASR::SubroutineCall_t>(*x.m_overloaded) ) {
-                    ASR::SubroutineCall_t* assign_call = ASR::down_cast<ASR::SubroutineCall_t>(xx.m_overloaded);
-                    Vec<ASR::call_arg_t> assign_call_args;
-                    assign_call_args.reserve(al, 2);
-                    assign_call_args.push_back(al, assign_call->m_args[0]);
-                    ASR::call_arg_t arg_1;
-                    arg_1.loc = assign_call->m_args[1].loc;
-                    arg_1.m_value = result_var;
-                    assign_call_args.push_back(al, arg_1);
-                    x_m_overloaded = ASRUtils::STMT(ASR::make_SubroutineCall_t(al, x_m_overloaded->base.loc,
-                                        assign_call->m_name, assign_call->m_original_name, assign_call_args.p,
-                                        assign_call_args.size(), assign_call->m_dt));
+                Vec<ASR::stmt_t*>* result_vec = nullptr;
+                if( inside_symtab ) {
+                    if( symtab2decls.find(current_scope) == symtab2decls.end() ) {
+                        Vec<ASR::stmt_t*> result_vec_;
+                        result_vec_.reserve(al, 0);
+                        symtab2decls[current_scope] = result_vec_;
+                    }
+                    result_vec = &symtab2decls[current_scope];
+                } else {
+                    result_vec = &pass_result;
                 }
-                pass_result.push_back(al, ASRUtils::STMT(ASR::make_Assignment_t(al, x.base.base.loc, x.m_target,
-                                                result_var, x_m_overloaded)));
+                ASR::symbol_t *v = nullptr;
+                if (ASR::is_a<ASR::Var_t>(*result_var)) {
+                    v = ASR::down_cast<ASR::Var_t>(result_var)->m_v;
+                }
+                ASR::expr_t* derived_ref = ASRUtils::EXPR(ASRUtils::getStructInstanceMember_t(al,
+                                                x->base.base.loc, (ASR::asr_t*) result_var, v,
+                                                member, current_scope));
+                ASR::stmt_t* assign = ASRUtils::STMT(ASR::make_Assignment_t(al,
+                                            x->base.base.loc, derived_ref,
+                                            x->m_args[i].m_value, nullptr));
+                result_vec->push_back(al, assign);
             }
         }
-
     }
+};
 
-    void visit_StructTypeConstructor(const ASR::StructTypeConstructor_t &x) {
-        if( x.n_args == 0 ) {
-            remove_original_stmt = true;
+class StructTypeConstructorVisitor : public ASR::CallReplacerOnExpressionsVisitor<StructTypeConstructorVisitor>
+{
+    private:
+
+        Allocator& al;
+        bool remove_original_statement;
+        bool inside_symtab;
+        ReplaceStructTypeConstructor replacer;
+        Vec<ASR::stmt_t*> pass_result;
+        std::map<SymbolTable*, Vec<ASR::stmt_t*>> symtab2decls;
+
+    public:
+
+        StructTypeConstructorVisitor(Allocator& al_) :
+        al(al_), remove_original_statement(false),
+        inside_symtab(true), replacer(al_, pass_result,
+            remove_original_statement, inside_symtab,
+            symtab2decls) {
+            pass_result.n = 0;
+            pass_result.reserve(al, 0);
         }
-        ASR::Struct_t* dt_der = down_cast<ASR::Struct_t>(x.m_type);
-        ASR::StructType_t* dt_dertype = ASR::down_cast<ASR::StructType_t>(
-                                         ASRUtils::symbol_get_past_external(dt_der->m_derived_type));
-        for( size_t i = 0; i < std::min(dt_dertype->n_members, x.n_args); i++ ) {
-            ASR::symbol_t* member = dt_dertype->m_symtab->resolve_symbol(std::string(dt_dertype->m_members[i], strlen(dt_dertype->m_members[i])));
-            ASR::symbol_t *v = nullptr;
-            if (is_a<ASR::Var_t>(*result_var)) {
-                v = down_cast<ASR::Var_t>(result_var)->m_v;
+
+        void call_replacer() {
+            replacer.current_expr = current_expr;
+            replacer.current_scope = current_scope;
+            replacer.replace_expr(*current_expr);
+        }
+
+        void transform_stmts(ASR::stmt_t **&m_body, size_t &n_body) {
+            bool inside_symtab_copy = inside_symtab;
+            inside_symtab = false;
+            Vec<ASR::stmt_t*> body;
+            body.reserve(al, n_body);
+
+            if( symtab2decls.find(current_scope) != symtab2decls.end() ) {
+                Vec<ASR::stmt_t*>& decls = symtab2decls[current_scope];
+                for (size_t j = 0; j < decls.size(); j++) {
+                    body.push_back(al, decls[j]);
+                }
+                symtab2decls.erase(current_scope);
+            }
+
+            for (size_t i = 0; i < n_body; i++) {
+                pass_result.n = 0;
+                pass_result.reserve(al, 1);
+                remove_original_statement = false;
+                replacer.result_var = nullptr;
+                visit_stmt(*m_body[i]);
+                for (size_t j = 0; j < pass_result.size(); j++) {
+                    body.push_back(al, pass_result[j]);
+                }
+                if( !remove_original_statement ) {
+                    body.push_back(al, m_body[i]);
+                }
+                remove_original_statement = false;
             }
-            ASR::expr_t* derived_ref = ASRUtils::EXPR(ASRUtils::getStructInstanceMember_t(al, x.base.base.loc, (ASR::asr_t*)result_var, v, member, current_scope));
-            ASR::stmt_t* assign = ASRUtils::STMT(ASR::make_Assignment_t(al, x.base.base.loc, derived_ref, x.m_args[i], nullptr));
-            pass_result.push_back(al, assign);
+            m_body = body.p;
+            n_body = body.size();
+            replacer.result_var = nullptr;
+            pass_result.n = 0;
+            pass_result.reserve(al, 0);
+            inside_symtab = inside_symtab_copy;
         }
-    }
+
+        void visit_Variable(const ASR::Variable_t &x) {
+            ASR::Variable_t& xx = const_cast<ASR::Variable_t&>(x);
+            replacer.result_var = ASRUtils::EXPR(ASR::make_Var_t(al,
+                                    x.base.base.loc, &(xx.base)));
+            ASR::CallReplacerOnExpressionsVisitor<
+                StructTypeConstructorVisitor>::visit_Variable(x);
+        }
+
+        void visit_Assignment(const ASR::Assignment_t &x) {
+            if (x.m_overloaded) {
+                this->visit_stmt(*x.m_overloaded);
+                remove_original_statement = false;
+                return ;
+            }
+
+            replacer.result_var = x.m_target;
+            ASR::expr_t** current_expr_copy_9 = current_expr;
+            current_expr = const_cast<ASR::expr_t**>(&(x.m_value));
+            this->call_replacer();
+            current_expr = current_expr_copy_9;
+            if( !remove_original_statement ) {
+                this->visit_expr(*x.m_value);
+            }
+        }
+
 };
 
-void pass_replace_class_constructor(Allocator &al, ASR::TranslationUnit_t &unit,
-                                    const LCompilers::PassOptions& /*pass_options*/) {
-    ClassConstructorVisitor v(al);
-    do {
-        v.is_constructor_present = false;
-        v.visit_TranslationUnit(unit);
-    } while( v.is_constructor_present );
+void pass_replace_class_constructor(Allocator &al,
+    ASR::TranslationUnit_t &unit,
+    const LCompilers::PassOptions& /*pass_options*/) {
+    StructTypeConstructorVisitor v(al);
+    v.visit_TranslationUnit(unit);
+    PassUtils::UpdateDependenciesVisitor w(al);
+    w.visit_TranslationUnit(unit);
 }
 
 

src/lpython/semantics/python_ast_to_asr.cpp

@@ -1138,15 +1138,12 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                     s_generic, args_new.p, args_new.size(), nullptr);
             }
         } else if(ASR::is_a<ASR::StructType_t>(*s)) {
-            Vec<ASR::expr_t*> args_new;
-            args_new.reserve(al, args.size());
-            visit_expr_list(args, args.size(), args_new);
             ASR::StructType_t* StructType = ASR::down_cast<ASR::StructType_t>(s);
             for( size_t i = 0; i < std::min(args.size(), StructType->n_members); i++ ) {
                 std::string member_name = StructType->m_members[i];
                 ASR::Variable_t* member_var = ASR::down_cast<ASR::Variable_t>(
                                                 StructType->m_symtab->resolve_symbol(member_name));
-                ASR::expr_t* arg_new_i = args_new[i];
+                ASR::expr_t* arg_new_i = args[i].m_value;
                 cast_helper(member_var->m_type, arg_new_i, arg_new_i->base.loc);
                 ASR::ttype_t* left_type = member_var->m_type;
                 ASR::ttype_t* right_type = ASRUtils::expr_type(arg_new_i);
@@ -1162,10 +1159,10 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                     );
                     throw SemanticAbort();
                 }
-                args_new.p[i] = arg_new_i;
+                args.p[i].m_value = arg_new_i;
             }
             ASR::ttype_t* der_type = ASRUtils::TYPE(ASR::make_Struct_t(al, loc, stemp, nullptr, 0));
-            return ASR::make_StructTypeConstructor_t(al, loc, stemp, args_new.p, args_new.size(), der_type, nullptr);
+            return ASR::make_StructTypeConstructor_t(al, loc, stemp, args.p, args.size(), der_type, nullptr);
         } else if( ASR::is_a<ASR::EnumType_t>(*s) ) {
             Vec<ASR::expr_t*> args_new;
             args_new.reserve(al, args.size());

tests/reference/asr-structs_01-be14d49.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-structs_01-be14d49.stdout",
-    "stdout_hash": "bd6651b101dc97e717d0604af576a8492e549d6830a89ae0b2d2a83f",
+    "stdout_hash": "7fc590bac6faf35bb632814509f73079edbd4c868b32dcfcf5efe3f2",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0