Merge pull request #1085 from Shaikh-Ubaid/pass_print_list

PASS: print list

Author: ubaidsk

integration_tests/CMakeLists.txt

@@ -166,6 +166,7 @@ RUN(NAME expr_10             LABELS cpython llvm)
 RUN(NAME expr_11             LABELS cpython llvm c wasm)
 RUN(NAME expr_12             LABELS llvm c)
 RUN(NAME loop_01             LABELS cpython llvm c)
+RUN(NAME print_02            LABELS cpython llvm)
 RUN(NAME test_types_01       LABELS cpython llvm)
 RUN(NAME test_str_01         LABELS cpython llvm)
 RUN(NAME test_str_02         LABELS cpython llvm)

integration_tests/print_02.py

@@ -0,0 +1,84 @@
+from ltypes import i32, f64
+
+# Test: Printing ListConstant
+def f():
+    a: list[str] = ["ab", "abc", "abcd"]
+    b: list[i32] = [1, 2, 3, 4]
+    c: list[f64] = [1.23 , 324.3 , 56.431, 90.5, 34.1]
+    d: list[i32] = []
+
+    print(a)
+    print(b)
+    print(c)
+    print(d)
+
+    # print list constant
+    print([-3, 2, 1, 0])
+    print(['a', 'b', 'c', 'd' , 'e', 'f'])
+
+def test_nested_lists():
+    w: list[list[list[list[list[f64]]]]] = [[[[[2.13, -98.17]]], [[[1.11]]]]]
+    x: list[list[list[i32]]] = [[[3, -1], [-2, 5], [5]], [[-3, 1], [2, -5], [-5]]]
+    y: list[list[f64]] = [[3.14, -1.0012], [-2.38, 5.51]]
+    z: list[list[str]] = [["bat", "ball"], ["cat", "dog"], ["c", "c++", "java", "python"]]
+
+    print(w)
+    print(x)
+    print(y)
+    print(z)
+
+def test_nested_lists2():
+    # It tests list printing on scale like lists of size (approx) 100.
+
+    # shape = (10, 10), values range from 0 to 99 (both inclusive)
+    p: list[list[i32]] = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [10, 11, 12, 13, 14, 15, 16, 17, 18, 19], [20, 21, 22, 23, 24, 25, 26, 27, 28, 29], [30, 31, 32, 33, 34, 35, 36, 37, 38, 39], [40, 41, 42, 43, 44, 45, 46, 47, 48, 49], [50, 51, 52, 53, 54, 55, 56, 57, 58, 59], [60, 61, 62, 63, 64, 65, 66, 67, 68, 69], [70, 71, 72, 73, 74, 75, 76, 77, 78, 79], [80, 81, 82, 83, 84, 85, 86, 87, 88, 89], [90, 91, 92, 93, 94, 95, 96, 97, 98, 99]]
+
+    # shape = (3, 3, 3, 3), values range between [-101.00, 101.00)
+    q: list[list[list[list[f64]]]] = [[[[  74.55,  -77.64,   52.35],
+         [ -78.25,  -19.24,   81.38],
+         [   7.86,   12.11,   27.5 ]],
+
+        [[ -98.93,  -79.62,  -73.76],
+         [  42.05,  -90.29,   69.95],
+         [  59.32,  -70.78,  -53.22]],
+
+        [[  53.52,  -93.88,   49.65],
+         [   2.18,   19.91,   69.24],
+         [  78.51,   89.69,  -86.68]]],
+
+
+       [[[ -92.48,  -80.75,  -27.76],
+         [ -13.35,   12.28,   79.61],
+         [  48.48,  -10.49,   41.1 ]],
+
+        [[  20.33,   14.52,   82.56],
+         [ -57.76,   76.03,   67.33],
+         [ -21.5 ,  -11.92,  -31.84]],
+
+        [[   9.65,   11.15,  -36.58],
+         [  56.55,  -70.85,  -50.67],
+         [  94.63,   25.68,   89.3 ]]],
+
+
+       [[[  28.53,   71.22,   71.87],
+         [ -58.39,   -6.96,   42.98],
+         [  -8.95,  -75.09,   37.96]],
+
+        [[ -31.75,   67.33,   58.17],
+         [ -64.01,   -9.22,    9.59],
+         [  15.71,   82.36,   51.18]],
+
+        [[-100.29,  -32.72,  -54.94],
+         [  -0.32,   68.81,  -55.09],
+         [  97.28,  -28.2 ,  -62.61]]]]
+
+    # shape = (5, 5, 5), where each element is a string of random alphanumerals and length betweem 0 and 10
+    r: list[list[list[str]]] = [[['Io', 'tl', 'bLvjV', 'wjFKQ', 'lY2'], ['Be2l6bqE', 'pQER3utIXA', 'llZBJj5Cdu', 'C8', 'gwTr77PdYR'], ['4M6L', 'ktPdowqERy', 'KSifqTkR', 'ZE2p1N78f1', 'Mi5e87Xw'], ['uwfzqDq9g', 'QaM1s', '', '', 'LB'], ['OJFRY6k', 'iz7Oie', '', 'LUYLF', 'JBND5FuV7l']], [['m', 'WIQBQfV', 'jxjDrqxu', 'kea', 'mu'], ['', 'GI8aOwLMe', 'Y5m8', 'a02Rz', 'xNKCJ'], ['LzkhyiJQHP', 'uzc3xyoXL', 'sKGnYfpRy', '7x', 'WTVKrnPO'], ['TZa6', 'GXRuyRX', 'R', 'JQxS', 'OH'], ['bSVJZ1OQ', 'M', 'I9omlF', 'x7FR', 'XtpL']], [['DKOpK', 'eg8Nz', 'ru', 'Sj', 'YUDxyI'], ['Q5uyhvp', 'Ydx', 'p', 'DLM5RX', 'pwOujxCO'], ['s5GOWnNJV', 'af', 'KAkD', '4IIZK', 'JQK040x'], ['9vF', '9pc7R8v', 'nDReIU7', 'K', 'btn'], ['', 'wVeivkdi', '', '', 'C']], [['vNTtcRXD', 'rsi', 'YsoF7mZD', 'VrPXU50rgA', 'mG7zqN0G'], ['la7cJ', 'M5rLJ8Go', 'gb', 'FjKwYZ7E', 'uSPD'], ['', 'oOa79jWcMx', 'yyAYZZ', 'wbvggXm', 'aE3BkCL4'], ['RdP', 'Hwc0x9RZ', 'sy', '9', 'W1d9xA2BXe'], ['A', '', 'QnK', 'N5tzN', 'ou7Lp']], [['DL68rDF', 'v', 'kQ3Mxm', 'g', '6KTeF4Eo'], ['Hx9', 'Y1IzQm85Z4', '3D8', 'ZLZ5', 'rWn'], ['LtT', 'Dh5B', 'M', 'F', 'QTARbY'], ['Sh', 'WL', 'yvAfWvZSx1', '90yx', 'v'], ['', '7IBW', 'nI', '', '6Cbp5c8RT']]]
+
+    print(p)
+    print(q)
+    print(r)
+
+f()
+test_nested_lists()
+test_nested_lists2()

run_tests.py

@@ -25,7 +25,7 @@ def single_test(test, specific_test, verbose, no_llvm, update_reference):
     pass_ = test.get("pass", None)
     optimization_passes = ["flip_sign", "div_to_mul", "fma", "sign_from_value",
                            "inline_function_calls", "loop_unroll",
-                           "dead_code_removal", "loop_vectorise"]
+                           "dead_code_removal", "loop_vectorise", "print_list"]
 
     if pass_ and (pass_ not in ["do_loops", "global_stmts"] and
                   pass_ not in optimization_passes):

src/libasr/CMakeLists.txt

@@ -35,6 +35,7 @@ set(SRC
     pass/class_constructor.cpp
     pass/arr_slice.cpp
     pass/print_arr.cpp
+    pass/print_list.cpp
     pass/pass_utils.cpp
     pass/unused_functions.cpp
     pass/flip_sign.cpp

src/libasr/pass/pass_manager.h

@@ -22,6 +22,7 @@
 #include <libasr/pass/global_stmts.h>
 #include <libasr/pass/param_to_const.h>
 #include <libasr/pass/print_arr.h>
+#include <libasr/pass/print_list.h>
 #include <libasr/pass/arr_slice.h>
 #include <libasr/pass/flip_sign.h>
 #include <libasr/pass/div_to_mul.h>
@@ -59,6 +60,7 @@ namespace LCompilers {
             {"array_op", &LFortran::pass_replace_array_op},
             {"arr_slice", &LFortran::pass_replace_arr_slice},
             {"print_arr", &LFortran::pass_replace_print_arr},
+            {"print_list", &LFortran::pass_replace_print_list},
             {"class_constructor", &LFortran::pass_replace_class_constructor},
             {"unused_functions", &LFortran::pass_unused_functions},
             {"flip_sign", &LFortran::pass_replace_flip_sign},
@@ -97,6 +99,7 @@ namespace LCompilers {
                 "arr_slice",
                 "array_op",
                 "print_arr",
+                "print_list",
                 "array_dim_intrinsics_update",
                 "do_loops",
                 "forall",
@@ -113,6 +116,7 @@ namespace LCompilers {
                 "arr_slice",
                 "array_op",
                 "print_arr",
+                "print_list",
                 "loop_vectorise",
                 "loop_unroll",
                 "array_dim_intrinsics_update",

src/libasr/pass/print_list.cpp

@@ -0,0 +1,210 @@
+#include <libasr/asr.h>
+#include <libasr/containers.h>
+#include <libasr/exception.h>
+#include <libasr/asr_utils.h>
+#include <libasr/asr_verify.h>
+#include <libasr/pass/pass_utils.h>
+#include <libasr/pass/print_list.h>
+
+namespace LFortran {
+
+/*
+This ASR pass replaces print list with print every value,
+comma_space, brackets and newline. The function
+`pass_replace_print_list` transforms the ASR tree in-place.
+
+Converts:
+
+    print(l, sep="pqr", end="xyz") # l is a list
+
+to:
+
+    print("[", end="")
+    for i in range(len(l)):
+        print(l[i], end="")
+        if i < len(l) - 1:
+            print(", ", end="")
+    print("]", sep="pqr", end="xyz")
+
+for nested lists it transforms to:
+
+    print("[", end="")
+    for i in range(len(l)):
+        # print(l[i], end="") is replaced by the following code
+
+        print("[", end="")
+        for i1 in range(len(l[i])):
+            print(l[i][i1], end="")
+            if i1 < len(l[i]) - 1:
+                print(", ", end="")
+        print("]")
+
+        if i < len(l) - 1:
+            print(", ", end="")
+    print("]", sep="pqr", end="xyz")
+
+Note: In code, the variable `i` is named as `__list_iterator`
+*/
+
+class PrintListVisitor
+    : public PassUtils::PassVisitor<PrintListVisitor> {
+   private:
+    std::string rl_path;
+
+   public:
+    PrintListVisitor(Allocator &al, const std::string &rl_path_)
+        : PassVisitor(al, nullptr), rl_path(rl_path_) {
+        pass_result.reserve(al, 1);
+    }
+
+    void visit_Print(const ASR::Print_t &x) {
+        if (x.n_values == 1 &&
+            ASR::is_a<ASR::List_t>(*ASRUtils::expr_type(x.m_values[0]))) {
+            ASR::List_t *listC =
+                ASR::down_cast<ASR::List_t>(ASRUtils::expr_type(x.m_values[0]));
+
+            ASR::ttype_t *int_type = ASRUtils::TYPE(
+                ASR::make_Integer_t(al, x.base.base.loc, 4, nullptr, 0));
+            ASR::ttype_t *bool_type = ASRUtils::TYPE(
+                ASR::make_Logical_t(al, x.base.base.loc, 4, nullptr, 0));
+            ASR::ttype_t *str_type_len_0 = ASRUtils::TYPE(ASR::make_Character_t(
+                al, x.base.base.loc, 1, 0, nullptr, nullptr, 0));
+            ASR::ttype_t *str_type_len_1 = ASRUtils::TYPE(ASR::make_Character_t(
+                al, x.base.base.loc, 1, 1, nullptr, nullptr, 0));
+            ASR::ttype_t *str_type_len_2 = ASRUtils::TYPE(ASR::make_Character_t(
+                al, x.base.base.loc, 1, 2, nullptr, nullptr, 0));
+            ASR::expr_t *comma_space =
+                ASRUtils::EXPR(ASR::make_StringConstant_t(
+                    al, x.base.base.loc, s2c(al, ", "), str_type_len_2));
+            ASR::expr_t *single_quote =
+                ASRUtils::EXPR(ASR::make_StringConstant_t(
+                    al, x.base.base.loc, s2c(al, "'"), str_type_len_1));
+            ASR::expr_t *empty_str = ASRUtils::EXPR(ASR::make_StringConstant_t(
+                al, x.base.base.loc, s2c(al, ""), str_type_len_0));
+            ASR::expr_t *open_bracket =
+                ASRUtils::EXPR(ASR::make_StringConstant_t(
+                    al, x.base.base.loc, s2c(al, "["), str_type_len_1));
+            ASR::expr_t *close_bracket =
+                ASRUtils::EXPR(ASR::make_StringConstant_t(
+                    al, x.base.base.loc, s2c(al, "]"), str_type_len_1));
+
+            std::string list_iter_var_name;
+            ASR::symbol_t *list_iter_variable;
+            ASR::expr_t *list_iter_var;
+            {
+                list_iter_var_name =
+                    current_scope->get_unique_name("__list_iterator");
+                list_iter_variable =
+                    ASR::down_cast<ASR::symbol_t>(ASR::make_Variable_t(
+                        al, x.base.base.loc, current_scope,
+                        s2c(al, list_iter_var_name), ASR::intentType::Local,
+                        nullptr, nullptr, ASR::storage_typeType::Default,
+                        int_type, ASR::abiType::Source, ASR::accessType::Public,
+                        ASR::presenceType::Required, false));
+
+                current_scope->add_symbol(list_iter_var_name,
+                                          list_iter_variable);
+                list_iter_var = ASRUtils::EXPR(
+                    ASR::make_Var_t(al, x.base.base.loc, list_iter_variable));
+            }
+
+            ASR::expr_t *list_item = ASRUtils::EXPR(
+                ASR::make_ListItem_t(al, x.base.base.loc, x.m_values[0],
+                                     list_iter_var, listC->m_type, nullptr));
+            ASR::expr_t *list_len = ASRUtils::EXPR(ASR::make_ListLen_t(
+                al, x.base.base.loc, x.m_values[0], int_type, nullptr));
+            ASR::expr_t *constant_one = ASRUtils::EXPR(
+                ASR::make_IntegerConstant_t(al, x.base.base.loc, 1, int_type));
+            ASR::expr_t *list_len_minus_one =
+                ASRUtils::EXPR(ASR::make_IntegerBinOp_t(
+                    al, x.base.base.loc, list_len, ASR::binopType::Sub,
+                    constant_one, int_type, nullptr));
+            ASR::expr_t *compare_cond =
+                ASRUtils::EXPR(ASR::make_IntegerCompare_t(
+                    al, x.base.base.loc, list_iter_var, ASR::cmpopType::Lt,
+                    list_len_minus_one, bool_type, nullptr));
+
+            Vec<ASR::expr_t *> v1, v2, v3, v4;
+            v1.reserve(al, 1);
+            v3.reserve(al, 1);
+            v4.reserve(al, 1);
+            v1.push_back(al, open_bracket);
+            v3.push_back(al, close_bracket);
+            v4.push_back(al, comma_space);
+
+            if (ASR::is_a<ASR::Character_t>(*listC->m_type)) {
+                v2.reserve(al, 3);
+                v2.push_back(al, single_quote);
+                v2.push_back(al, list_item);
+                v2.push_back(al, single_quote);
+            } else {
+                v2.reserve(al, 1);
+                v2.push_back(al, list_item);
+            }
+
+            ASR::stmt_t *print_open_bracket = LFortran::ASRUtils::STMT(
+                ASR::make_Print_t(al, x.base.base.loc, nullptr, v1.p, v1.size(),
+                                  nullptr, empty_str));
+            ASR::stmt_t *print_comma_space = ASRUtils::STMT(
+                ASR::make_Print_t(al, x.base.base.loc, nullptr, v4.p, v4.size(),
+                                  empty_str, empty_str));
+            ASR::stmt_t *print_item = ASRUtils::STMT(
+                ASR::make_Print_t(al, x.base.base.loc, nullptr, v2.p, v2.size(),
+                                  empty_str, empty_str));
+            ASR::stmt_t *print_close_bracket = LFortran::ASRUtils::STMT(
+                ASR::make_Print_t(al, x.base.base.loc, nullptr, v3.p, v3.size(),
+                                  x.m_separator, x.m_end));
+
+            Vec<ASR::stmt_t *> if_body;
+            if_body.reserve(al, 1);
+            if_body.push_back(al, print_comma_space);
+
+            ASR::stmt_t *if_cond = ASRUtils::STMT(
+                ASR::make_If_t(al, x.base.base.loc, compare_cond, if_body.p,
+                               if_body.size(), nullptr, 0));
+
+            ASR::do_loop_head_t loop_head;
+            Vec<ASR::stmt_t *> loop_body;
+            {
+                loop_head.loc = x.base.base.loc;
+                loop_head.m_v = list_iter_var;
+                loop_head.m_start = ASRUtils::EXPR(ASR::make_IntegerConstant_t(
+                    al, x.base.base.loc, 0, int_type));
+                loop_head.m_end = list_len_minus_one;
+                loop_head.m_increment =
+                    ASRUtils::EXPR(ASR::make_IntegerConstant_t(
+                        al, x.base.base.loc, 1, int_type));
+
+                if (!ASR::is_a<ASR::List_t>(*listC->m_type)) {
+                    loop_body.reserve(al, 2);
+                    loop_body.push_back(al, print_item);
+                } else {
+                    visit_Print(*ASR::down_cast<ASR::Print_t>(print_item));
+                    loop_body.from_pointer_n_copy(al, pass_result.p, pass_result.size());
+                    pass_result.n = 0;
+                }
+                loop_body.push_back(al, if_cond);
+            }
+
+            ASR::stmt_t *loop = ASRUtils::STMT(ASR::make_DoLoop_t(
+                al, x.base.base.loc, loop_head, loop_body.p, loop_body.size()));
+
+            {
+                pass_result.push_back(al, print_open_bracket);
+                pass_result.push_back(al, loop);
+                pass_result.push_back(al, print_close_bracket);
+            }
+        }
+    }
+};
+
+void pass_replace_print_list(
+    Allocator &al, ASR::TranslationUnit_t &unit,
+    const LCompilers::PassOptions &pass_options) {
+    std::string rl_path = pass_options.runtime_library_dir;
+    PrintListVisitor v(al, rl_path);
+    v.visit_TranslationUnit(unit);
+    LFORTRAN_ASSERT(asr_verify(unit));
+}
+
+}  // namespace LFortran

src/libasr/pass/print_list.h

@@ -0,0 +1,15 @@
+#ifndef LFORTRAN_PASS_PRINT_LIST_H
+#define LFORTRAN_PASS_PRINT_LIST_H
+
+#include <libasr/asr.h>
+#include <libasr/utils.h>
+
+namespace LFortran {
+
+    void pass_replace_print_list(
+    Allocator &al, ASR::TranslationUnit_t &unit,
+    const LCompilers::PassOptions &pass_options);
+
+} // namespace LFortran
+
+#endif // LFORTRAN_PASS_PRINT_LIST_H

tests/reference/asr-print_02-afbe092.json

@@ -0,0 +1,13 @@
+{
+    "basename": "asr-print_02-afbe092",
+    "cmd": "lpython --show-asr --no-color {infile} -o {outfile}",
+    "infile": "tests/../integration_tests/print_02.py",
+    "infile_hash": "80609aedaf75258395fafe6c444c79cc3217f000380bd39e1b0f6a84",
+    "outfile": null,
+    "outfile_hash": null,
+    "stdout": "asr-print_02-afbe092.stdout",
+    "stdout_hash": "4426c0f2cb900df00ddd7facbec9b7648c60d703a4fec573bdaf57e0",
+    "stderr": null,
+    "stderr_hash": null,
+    "returncode": 0
+}

tests/reference/asr-print_02-afbe092.stdout

@@ -0,0 +1,13 @@
+{
+    "basename": "pass_print_list-print_02-d2853f6",
+    "cmd": "lpython --pass=print_list --show-asr --no-color {infile} -o {outfile}",
+    "infile": "tests/../integration_tests/print_02.py",
+    "infile_hash": "80609aedaf75258395fafe6c444c79cc3217f000380bd39e1b0f6a84",
+    "outfile": null,
+    "outfile_hash": null,
+    "stdout": "pass_print_list-print_02-d2853f6.stdout",
+    "stdout_hash": "b5d47019cefd1d9b5a0c7e6a4ff68c91844af269bb9af00f0fc2afb8",
+    "stderr": null,
+    "stderr_hash": null,
+    "returncode": 0
+}