Merge branch 'main' into pkg_convexhull

Author: ubaidsk

integration_tests/CMakeLists.txt

@@ -372,6 +372,7 @@ RUN(NAME test_list_07        LABELS cpython llvm c)
 RUN(NAME test_list_08        LABELS cpython llvm c)
 RUN(NAME test_list_09        LABELS cpython llvm c)
 RUN(NAME test_list_10        LABELS cpython llvm c)
+RUN(NAME test_list_11        LABELS cpython llvm c)
 RUN(NAME test_list_section   LABELS cpython llvm c)
 RUN(NAME test_list_count     LABELS cpython llvm)
 RUN(NAME test_list_index     LABELS cpython llvm)

integration_tests/test_list_11.py

@@ -0,0 +1,12 @@
+from lpython import i32
+
+def return_empty_list_of_tuples() -> list[i32]:
+    return []
+
+def main0():
+    x: list[i32] = return_empty_list_of_tuples()
+    print(len(x))
+
+    assert len(x) == 0
+
+main0()

src/bin/lpython.cpp

@@ -444,7 +444,7 @@ int emit_wat(const std::string &infile,
     LCompilers::ASR::TranslationUnit_t* asr = r1.result;
 
     diagnostics.diagnostics.clear();
-    LCompilers::Result<LCompilers::Vec<uint8_t>> r2 = LCompilers::asr_to_wasm_bytes_stream(*asr, al, diagnostics);
+    LCompilers::Result<LCompilers::Vec<uint8_t>> r2 = LCompilers::asr_to_wasm_bytes_stream(*asr, al, diagnostics, compiler_options);
     std::cerr << diagnostics.render(lm, compiler_options);
     if (!r2.ok) {
         LCOMPILERS_ASSERT(diagnostics.has_error())
@@ -918,7 +918,7 @@ int compile_to_binary_wasm(
 
     // ASR -> WASM
     auto asr_to_wasm_start = std::chrono::high_resolution_clock::now();
-    LCompilers::Result<int> res = LCompilers::asr_to_wasm(*asr, al,  outfile, time_report, diagnostics);
+    LCompilers::Result<int> res = LCompilers::asr_to_wasm(*asr, al,  outfile, time_report, diagnostics, compiler_options);
     auto asr_to_wasm_end = std::chrono::high_resolution_clock::now();
     times.push_back(std::make_pair("ASR to WASM", std::chrono::duration<double, std::milli>(asr_to_wasm_end - asr_to_wasm_start).count()));
     std::cerr << diagnostics.render(lm, compiler_options);
@@ -1065,7 +1065,7 @@ int compile_to_binary_wasm_to_x86(
 
     // ASR -> WASM
     auto asr_to_wasm_start = std::chrono::high_resolution_clock::now();
-    LCompilers::Result<LCompilers::Vec<uint8_t>> r3 = LCompilers::asr_to_wasm_bytes_stream(*asr, al, diagnostics);
+    LCompilers::Result<LCompilers::Vec<uint8_t>> r3 = LCompilers::asr_to_wasm_bytes_stream(*asr, al, diagnostics, compiler_options);
     auto asr_to_wasm_end = std::chrono::high_resolution_clock::now();
     times.push_back(std::make_pair("ASR to WASM", std::chrono::duration<double, std::milli>(asr_to_wasm_end - asr_to_wasm_start).count()));
     std::cerr << diagnostics.render(lm, compiler_options);
@@ -1349,7 +1349,7 @@ EMSCRIPTEN_KEEPALIVE char* emit_wat_from_source(char *input) {
         out = diagnostics.render(lm, compiler_options);
         if (asr.ok) {
             LCompilers::Result<LCompilers::Vec<uint8_t>>
-            wasm = LCompilers::asr_to_wasm_bytes_stream(*asr.result, al, diagnostics);
+            wasm = LCompilers::asr_to_wasm_bytes_stream(*asr.result, al, diagnostics, compiler_options);
             out = diagnostics.render(lm, compiler_options);
             if (wasm.ok) {
                 LCompilers::Result<std::string>
@@ -1414,7 +1414,7 @@ EMSCRIPTEN_KEEPALIVE char* emit_wasm_from_source(char *input) {
         out = diagnostics.render(lm, compiler_options);
         if (asr.ok) {
             LCompilers::Result<LCompilers::Vec<uint8_t>>
-            wasm = LCompilers::asr_to_wasm_bytes_stream(*asr.result, al, diagnostics);
+            wasm = LCompilers::asr_to_wasm_bytes_stream(*asr.result, al, diagnostics, compiler_options);
             out = diagnostics.render(lm, compiler_options);
             if (wasm.ok) {
                 out = "0"; // exit code

src/libasr/ASR.asdl

@@ -103,7 +103,8 @@ symbol
     | UnionType(symbol_table symtab, identifier name, identifier* dependencies,
         identifier* members, abi abi, access access, symbol? parent)
     | Variable(symbol_table parent_symtab, identifier name, identifier* dependencies,
-        intent intent, expr? symbolic_value, expr? value, storage_type storage, ttype type,
+        intent intent, expr? symbolic_value, expr? value, storage_type storage,
+        ttype type, symbol? type_declaration,
         abi abi, access access, presence presence, bool value_attr)
     | ClassType(symbol_table symtab, identifier name, abi abi, access access)
     | ClassProcedure(symbol_table parent_symtab, identifier name, identifier? self_argument,
@@ -284,6 +285,7 @@ expr
     | DictLen(expr arg, ttype type, expr? value)
 
     | Var(symbol v)
+    | FunctionParam(int param_number, ttype type, expr? value) --- used in types
 
     | ArrayConstant(expr* args, ttype type, arraystorage storage_format)
     | ArrayItem(expr v, array_index* args, ttype type, arraystorage storage_format, expr? value)

src/libasr/CMakeLists.txt

@@ -28,6 +28,7 @@ set(SRC
     codegen/wasm_utils.cpp
 
     pass/nested_vars.cpp
+    pass/where.cpp
     pass/param_to_const.cpp
     pass/do_loops.cpp
     pass/for_all.cpp
@@ -90,7 +91,7 @@ if (WITH_LLVM)
             COMPILE_FLAGS -Wno-deprecated-declarations)
     endif()
 endif()
-add_library(asr ${SRC})
+add_library(asr STATIC ${SRC})
 target_include_directories(asr BEFORE PUBLIC ${libasr_SOURCE_DIR}/..)
 target_include_directories(asr BEFORE PUBLIC ${libasr_BINARY_DIR}/..)
 if (WITH_BFD)

src/libasr/asdl_cpp.py

@@ -1169,7 +1169,9 @@ class ExprBaseReplacerVisitor(ASDLVisitor):
 
     def __init__(self, stream, data):
         self.replace_expr = []
+        self.replace_ttype = []
         self.is_expr = False
+        self.is_ttype = False
         self.is_product = False
         self.current_expr_copy_variable_count = 0
         super(ExprBaseReplacerVisitor, self).__init__(stream, data)
@@ -1195,16 +1197,32 @@ def visitModule(self, mod):
         self.replace_expr.append(("", 0))
         self.replace_expr.append(("    switch(x->type) {", 1))
 
+        self.replace_ttype.append(("    void replace_ttype(ASR::ttype_t* x) {", 0))
+        self.replace_ttype.append(("    if( !x ) {", 1))
+        self.replace_ttype.append(("    return ;", 2))
+        self.replace_ttype.append(("    }", 1))
+        self.replace_ttype.append(("", 0))
+        self.replace_ttype.append(("    switch(x->type) {", 1))
+
         super(ExprBaseReplacerVisitor, self).visitModule(mod)
 
         self.replace_expr.append(("    default: {", 2))
-        self.replace_expr.append(('    LCOMPILERS_ASSERT_MSG(false, "Duplication of " + std::to_string(x->type) + " expression is not supported yet.");', 3))
+        self.replace_expr.append(('    LCOMPILERS_ASSERT_MSG(false, "Replacement in  " + std::to_string(x->type) + " expression is not supported yet.");', 3))
         self.replace_expr.append(("    }", 2))
         self.replace_expr.append(("    }", 1))
         self.replace_expr.append(("", 0))
         self.replace_expr.append(("    }", 0))
+
+        self.replace_ttype.append(("    default: {", 2))
+        self.replace_ttype.append(('    LCOMPILERS_ASSERT_MSG(false, "Replacement in " + std::to_string(x->type) + " type is not supported yet.");', 3))
+        self.replace_ttype.append(("    }", 2))
+        self.replace_ttype.append(("    }", 1))
+        self.replace_ttype.append(("", 0))
+        self.replace_ttype.append(("    }", 0))
         for line, level in self.replace_expr:
             self.emit(line, level=level)
+        for line, level in self.replace_ttype:
+            self.emit(line, level=level)
         self.emit("")
         self.emit("};")
 
@@ -1215,7 +1233,8 @@ def visitType(self, tp):
 
     def visitSum(self, sum, *args):
         self.is_expr = args[0] == 'expr'
-        if self.is_expr:
+        self.is_ttype = args[0] == 'ttype'
+        if self.is_expr or self.is_ttype:
             for tp in sum.types:
                 self.visit(tp, *args)
 
@@ -1239,12 +1258,21 @@ def make_visitor(self, name, fields):
             self.replace_expr.append(("    self().replace_%s(down_cast<ASR::%s_t>(x));" % (name, name), 3))
             self.replace_expr.append(("    break;", 3))
             self.replace_expr.append(("    }", 2))
+        elif self.is_ttype:
+            self.replace_ttype.append(("    case ASR::ttypeType::%s: {" % name, 2))
+            self.replace_ttype.append(("    self().replace_%s(down_cast<ASR::%s_t>(x));" % (name, name), 3))
+            self.replace_ttype.append(("    break;", 3))
+            self.replace_ttype.append(("    }", 2))
         self.emit("}", 1)
         self.emit("")
 
     def visitField(self, field):
         arguments = None
-        if field.type == "expr" or field.type == "symbol" or field.type == "call_arg":
+        if (field.type == "expr" or
+            field.type == "symbol" or
+            field.type == "call_arg" or
+            field.type == "ttype" or
+            field.type == "dimension"):
             level = 2
             if field.seq:
                 self.used = True
@@ -1257,15 +1285,29 @@ def visitField(self, field):
                     self.emit("    current_expr = current_expr_copy_%d;" % (self.current_expr_copy_variable_count), level + 1)
                     self.emit("    }", level)
                     self.current_expr_copy_variable_count += 1
+                elif field.type == "dimension":
+                    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].m_length);" % (field.name), level)
+                    self.emit("    self().replace_expr(x->m_%s[i].m_length);"%(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("    ASR::expr_t** current_expr_copy_%d = current_expr;" % (self.current_expr_copy_variable_count), level)
+                    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)
+                    self.current_expr_copy_variable_count += 1
                 self.emit("}", level)
             else:
                 if field.type != "symbol":
                     self.used = True
-                    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);" % (field.name), level)
-                    self.emit("self().replace_%s(x->m_%s);" % (field.type, 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
+                    if field.type == "ttype":
+                        self.emit("self().replace_%s(x->m_%s);" % (field.type, field.name), level)
+                    else:
+                        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);" % (field.name), level)
+                        self.emit("self().replace_%s(x->m_%s);" % (field.type, 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
 
 class StmtBaseReplacerVisitor(ASDLVisitor):
 

src/libasr/asr_scopes.cpp

@@ -6,55 +6,6 @@
 
 namespace LCompilers  {
 
-// This function is taken from:
-// https://github.com/aappleby/smhasher/blob/61a0530f28277f2e850bfc39600ce61d02b518de/src/MurmurHash2.cpp#L37
-uint32_t murmur_hash(const void * key, int len, uint32_t seed)
-{
-    // 'm' and 'r' are mixing constants generated offline.
-    // They're not really 'magic', they just happen to work well.
-    const uint32_t m = 0x5bd1e995;
-    const int r = 24;
-    // Initialize the hash to a 'random' value
-    uint32_t h = seed ^ len;
-    // Mix 4 bytes at a time into the hash
-    const unsigned char * data = (const unsigned char *)key;
-    while(len >= 4)
-    {
-        uint32_t k = *(uint32_t*)data;
-        k *= m;
-        k ^= k >> r;
-        k *= m;
-        h *= m;
-        h ^= k;
-        data += 4;
-        len -= 4;
-    }
-    // Handle the last few bytes of the input array
-    switch(len)
-    {
-        case 3: h ^= data[2] << 16; // fall through
-        case 2: h ^= data[1] << 8;  // fall through
-        case 1: h ^= data[0];
-            h *= m;
-    };
-    // Do a few final mixes of the hash to ensure the last few
-    // bytes are well-incorporated.
-    h ^= h >> 13;
-    h *= m;
-    h ^= h >> 15;
-    return h;
-}
-
-uint32_t murmur_hash_str(const std::string &s, uint32_t seed)
-{
-    return murmur_hash(&s[0], s.length(), seed);
-}
-
-uint32_t murmur_hash_int(uint64_t i, uint32_t seed)
-{
-    return murmur_hash(&i, 8, seed);
-}
-
 template< typename T >
 std::string hexify(T i)
 {
@@ -75,7 +26,7 @@ void SymbolTable::reset_global_counter() {
     symbol_table_counter = 0;
 }
 
-void SymbolTable::mark_all_variables_external(Allocator &/*al*/) {
+void SymbolTable::mark_all_variables_external(Allocator &al) {
     for (auto &a : scope) {
         switch (a.second->type) {
             case (ASR::symbolType::Variable) : {
@@ -91,6 +42,10 @@ void SymbolTable::mark_all_variables_external(Allocator &/*al*/) {
                 v->n_body = 0;
                 break;
             }
+            case (ASR::symbolType::Module) : {
+                ASR::Module_t *v = ASR::down_cast<ASR::Module_t>(a.second);
+                v->m_symtab->mark_all_variables_external(al);
+            }
             default : {};
         }
     }