Use Vec instead of std::vector

Author: Thirumalai-Shaktivel

src/libasr/asr_scopes.cpp

@@ -135,9 +135,11 @@ std::string SymbolTable::get_unique_name(const std::string &name) {
     return unique_name;
 }
 
-void SymbolTable::move_symbols_from_global_scope(Allocator &/*al*/,
-        SymbolTable *module_scope, std::vector<std::string> &syms,
-        std::vector<char *> &mod_dependencies) {
+void SymbolTable::move_symbols_from_global_scope(Allocator &al,
+        SymbolTable *module_scope, Vec<char *> &syms,
+        Vec<char *> &mod_dependencies) {
+    syms.reserve(al, 4);
+    mod_dependencies.reserve(al, 4);
     for (auto &a : scope) {
         switch (a.second->type) {
             case (ASR::symbolType::Module): {
@@ -175,50 +177,50 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &/*al*/,
                         s = fn->m_symtab->parent->get_symbol(fn->m_dependencies[i]);
                     }
                     if (s != nullptr && ASR::is_a<ASR::ExternalSymbol_t>(*s)) {
-                        mod_dependencies.push_back(ASR::down_cast<
+                        mod_dependencies.push_back(al, ASR::down_cast<
                             ASR::ExternalSymbol_t>(s)->m_module_name);
                     }
                 }
                 fn->m_symtab->parent = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) fn);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::GenericProcedure) : {
                 ASR::GenericProcedure_t *es = ASR::down_cast<ASR::GenericProcedure_t>(a.second);
                 es->m_parent_symtab = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::ExternalSymbol) : {
                 ASR::ExternalSymbol_t *es = ASR::down_cast<ASR::ExternalSymbol_t>(a.second);
-                mod_dependencies.push_back(es->m_module_name);
+                mod_dependencies.push_back(al, es->m_module_name);
                 es->m_parent_symtab = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::StructType) : {
                 ASR::StructType_t *st = ASR::down_cast<ASR::StructType_t>(a.second);
                 st->m_symtab->parent = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) st);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::EnumType) : {
                 ASR::EnumType_t *et = ASR::down_cast<ASR::EnumType_t>(a.second);
                 et->m_symtab->parent = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) et);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::UnionType) : {
                 ASR::UnionType_t *ut = ASR::down_cast<ASR::UnionType_t>(a.second);
                 ut->m_symtab->parent = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) ut);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } case (ASR::symbolType::Variable) : {
                 ASR::Variable_t *v = ASR::down_cast<ASR::Variable_t>(a.second);
                 v->m_parent_symtab = module_scope;
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) v);
-                syms.push_back(a.first);
+                syms.push_back(al, s2c(al, a.first));
                 break;
             } default : {
                 throw LCompilersException("Moving the symbol:`" + a.first +

src/libasr/asr_scopes.h

@@ -4,6 +4,7 @@
 #include <map>
 
 #include <libasr/alloc.h>
+#include <libasr/containers.h>
 
 namespace LCompilers  {
 
@@ -82,8 +83,8 @@ struct SymbolTable {
     std::string get_unique_name(const std::string &name);
 
     void move_symbols_from_global_scope(Allocator &al,
-        SymbolTable *module_scope, std::vector<std::string> &syms,
-        std::vector<char *> &mod_dependencies);
+        SymbolTable *module_scope, Vec<char *> &syms,
+        Vec<char *> &mod_dependencies);
 };
 
 } // namespace LCompilers

src/libasr/pass/global_symbols.cpp

@@ -20,8 +20,8 @@ void pass_wrap_global_syms_into_module(Allocator &al,
     Location loc = unit.base.base.loc;
     char *module_name = s2c(al, "_global_symbols");
     SymbolTable *module_scope = al.make_new<SymbolTable>(unit.m_global_scope);
-    std::vector<std::string> moved_symbols;
-    std::vector<char *> mod_dependencies;
+    Vec<char *> moved_symbols;
+    Vec<char *> mod_dependencies;
 
     // Move all the symbols from global into the module scope
     unit.m_global_scope->move_symbols_from_global_scope(al, module_scope,