Merge pull request #1880 from czgdp1807/allocs

Add ``Allocatable`` and ``Array`` types

Author: czgdp1807

src/libasr/ASR.asdl

@@ -111,8 +111,10 @@ symbol
         identifier proc_name, symbol proc, abi abi, bool is_deferred)
     | AssociateBlock(symbol_table symtab, identifier name, stmt* body)
     | Block(symbol_table symtab, identifier name, stmt* body)
+    | Requirement(symbol_table symtab, identifier name, identifier* args)
+    | Template(symbol_table symtab, identifier name, identifier* args)
 
-storage_type = Default | Save | Parameter | Allocatable
+storage_type = Default | Save | Parameter
 access = Public | Private
 intent = Local | In | Out | InOut | ReturnVar | Unspecified
 deftype = Implementation | Interface
@@ -317,6 +319,7 @@ expr
     | EnumValue(expr v, ttype enum_type, ttype type, expr? value)
     | OverloadedCompare(expr left, cmpop op, expr right, ttype type, expr? value, expr overloaded)
     | OverloadedBinOp(expr left, binop op, expr right, ttype type, expr? value, expr overloaded)
+    | OverloadedUnaryMinus(expr arg, ttype type, expr? value, expr overloaded)
     | Cast(expr arg, cast_kind kind, ttype type, expr? value)
     | ComplexRe(expr arg, ttype type, expr? value)
     | ComplexIm(expr arg, ttype type, expr? value)
@@ -362,24 +365,26 @@ expr
 --     integer, so we also use kind=4 for the default logical.)
 
 ttype
-    = Integer(int kind, dimension* dims)
-    | UnsignedInteger(int kind, dimension* dims)
-    | Real(int kind, dimension* dims)
-    | Complex(int kind, dimension* dims)
-    | Character(int kind, int len, expr? len_expr, dimension* dims)
-    | Logical(int kind, dimension* dims)
+    = Integer(int kind)
+    | UnsignedInteger(int kind)
+    | Real(int kind)
+    | Complex(int kind)
+    | Character(int kind, int len, expr? len_expr)
+    | Logical(int kind)
     | Set(ttype type)
     | List(ttype type)
     | Tuple(ttype* type)
-    | Struct(symbol derived_type, dimension* dims)
-    | Enum(symbol enum_type, dimension *dims)
-    | Union(symbol union_type, dimension *dims)
-    | Class(symbol class_type, dimension* dims)
+    | Struct(symbol derived_type)
+    | Enum(symbol enum_type)
+    | Union(symbol union_type)
+    | Class(symbol class_type)
     | Dict(ttype key_type, ttype value_type)
     | Pointer(ttype type)
+    | Allocatable(ttype type)
     | Const(ttype type)
     | CPtr()
-    | TypeParameter(identifier param, dimension* dims)
+    | TypeParameter(identifier param)
+    | Array(ttype type, dimension* dims)
     | FunctionType(ttype* arg_types, ttype? return_var_type,
         abi abi, deftype deftype, string? bindc_name, bool elemental,
         bool pure, bool module, bool inline, bool static, ttype* type_params,

src/libasr/CMakeLists.txt

@@ -44,6 +44,7 @@ set(SRC
     pass/class_constructor.cpp
     pass/arr_slice.cpp
     pass/print_arr.cpp
+    pass/print_struct_type.cpp
     pass/print_list_tuple.cpp
     pass/pass_utils.cpp
     pass/unused_functions.cpp

src/libasr/asdl_cpp.py

@@ -417,7 +417,7 @@ def visitModule(self, mod):
         self.emit("private:")
         self.emit("    Struct& self() { return static_cast<Struct&>(*this); }")
         self.emit("public:")
-        self.emit("    SymbolTable* current_scope;")
+        self.emit("    SymbolTable* current_scope=nullptr;")
         self.emit("    void transform_stmts(ASR::stmt_t **&m_body, size_t &n_body) {")
         self.emit("    for (size_t i = 0; i < n_body; i++) {", 1)
         self.emit("        self().visit_stmt(*m_body[i]);", 1)
@@ -527,7 +527,7 @@ def visitModule(self, mod):
         self.emit("    Struct& self() { return static_cast<Struct&>(*this); }")
         self.emit("public:")
         self.emit("    ASR::expr_t** current_expr;")
-        self.emit("    SymbolTable* current_scope;")
+        self.emit("    SymbolTable* current_scope=nullptr;")
         self.emit("")
         self.emit("    void call_replacer() {}")
         self.emit("    void transform_stmts(ASR::stmt_t **&m_body, size_t &n_body) {")
@@ -1295,6 +1295,11 @@ def visitField(self, field):
                     self.emit("    current_expr = &(x->m_%s[i].m_start);" % (field.name), level)
                     self.emit("    self().replace_expr(x->m_%s[i].m_start);"%(field.name), level)
                     self.emit("    current_expr = current_expr_copy_%d;" % (self.current_expr_copy_variable_count), level)
+                elif field.type == "expr":
+                    self.emit("    ASR::expr_t** current_expr_copy_%d = current_expr;" % (self.current_expr_copy_variable_count), level)
+                    self.emit("    current_expr = &(x->m_%s[i]);" % (field.name), level)
+                    self.emit("    self().replace_expr(x->m_%s[i]);"%(field.name), level)
+                    self.emit("    current_expr = current_expr_copy_%d;" % (self.current_expr_copy_variable_count), level)
                     self.current_expr_copy_variable_count += 1
                 self.emit("}", level)
             else:

src/libasr/asr_scopes.cpp

@@ -152,8 +152,7 @@ void SymbolTable::move_symbols_from_global_scope(Allocator &al,
                 ASR::ExternalSymbol_t *es = ASR::down_cast<ASR::ExternalSymbol_t>(a.second);
                 mod_dependencies.push_back(al, es->m_module_name);
                 es->m_parent_symtab = module_scope;
-                ASR::symbol_t *s = ASRUtils::symbol_get_past_external(a.second);
-                LCOMPILERS_ASSERT(s);
+                LCOMPILERS_ASSERT(ASRUtils::symbol_get_past_external(a.second));
                 module_scope->add_symbol(a.first, (ASR::symbol_t *) es);
                 syms.push_back(al, s2c(al, a.first));
                 break;