Merge branch 'main' into i-1736

Author: Smit-create

integration_tests/CMakeLists.txt

@@ -529,6 +529,7 @@ RUN(NAME test_package_01     LABELS cpython llvm)
 RUN(NAME test_pkg_lpdraw     LABELS cpython llvm wasm)
 RUN(NAME test_pkg_lnn_01        LABELS cpython llvm)
 RUN(NAME test_pkg_lnn_02        LABELS cpython llvm)
+RUN(NAME test_pkg_lpconvexhull  LABELS cpython c)
 
 RUN(NAME generics_01         LABELS cpython llvm c)
 RUN(NAME generics_02         LABELS cpython llvm c)
@@ -539,7 +540,6 @@ RUN(NAME generics_list_01    LABELS cpython llvm c)
 RUN(NAME test_statistics     LABELS cpython llvm)
 RUN(NAME test_str_attributes LABELS cpython llvm c)
 RUN(NAME kwargs_01           LABELS cpython llvm c)
-RUN(NAME test_01_goto        LABELS cpython llvm c)
 
 RUN(NAME func_inline_01 LABELS llvm c wasm)
 RUN(NAME func_inline_02 LABELS cpython llvm c)

integration_tests/lpconvexhull/__init__.py

@@ -0,0 +1 @@
+from .lpconvexhull_main import convex_hull

integration_tests/lpconvexhull/lpconvexhull_main.py

@@ -0,0 +1,56 @@
+from lpython import i32
+from .utils import min, distance
+
+def orientation(p: tuple[i32, i32], q: tuple[i32, i32], r: tuple[i32, i32]) -> i32:
+    # Function to find the orientation of triplet (p, q, r)
+    # Returns the following values:
+    # 0: Colinear
+    # 1: Clockwise
+    # 2: Counterclockwise
+    value: i32 = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
+    if value == 0:
+        return 0  # Colinear
+    elif value > 0:
+        return 1  # Clockwise
+    else:
+        return 2  # Counterclockwise
+
+
+def convex_hull(points: list[tuple[i32, i32]]) -> list[tuple[i32, i32]]:
+    """Finds the convex hull of a set of points.
+
+    Args:
+        points: A list of points.
+
+    Returns:
+        A list of points that form the convex hull.
+    """
+
+    n: i32 = len(points)
+    if n < 3:
+        return [(-1, -1)]  # Convex hull not possible
+
+    # Find the leftmost point
+    leftmost: tuple[i32, i32] = min(points)
+    hull: list[tuple[i32, i32]] = []
+
+    p: tuple[i32, i32] = leftmost
+
+    while True:
+        hull.append(p)
+        q: tuple[i32, i32] = points[0]
+
+        r: tuple[i32, i32]
+        for r in points:
+            if r == p or r == q:
+                continue
+            direction: i32 = orientation(p, q, r)
+            if direction == 1 or (direction == 0 and distance(p, r) > distance(p, q)):
+                q = r
+
+        p = q
+
+        if p == leftmost:
+            break
+
+    return hull

integration_tests/lpconvexhull/utils.py

@@ -0,0 +1,29 @@
+from lpython import i32, f64
+
+def min(points: list[tuple[i32, i32]]) -> tuple[i32, i32]:
+    """Finds the left-most point in a list of points.
+
+    Args:
+        points: A list of points.
+
+    Returns:
+        The left-most point in the list.
+    """
+
+    left_most_point: tuple[i32, i32] = points[0]
+    point: tuple[i32, i32]
+    for point in points:
+        if point[0] < left_most_point[0]:
+            left_most_point = point
+
+    return left_most_point
+
+
+def distance(p: tuple[i32, i32], q: tuple[i32, i32]) -> f64:
+    # Function to calculate the Euclidean distance between two points
+    x1: i32; y1: i32
+    x2: i32; y2: i32
+
+    x1, y1 = p
+    x2, y2 = q
+    return f64((x2 - x1) ** 2 + (y2 - y1) ** 2) ** 0.5

integration_tests/test_01_goto.py

@@ -0,0 +1,32 @@
+from lpython import Const, i32, f64
+
+from lpdraw import Line, Circle, Clear, Display
+from lpconvexhull import convex_hull
+from numpy import empty, int32
+
+def plot_graph(polygon: list[tuple[i32, i32]], points: list[tuple[i32, i32]]):
+    Width: Const[i32] = 500 # x-axis limits [0, 499]
+    Height: Const[i32] = 500 # y-axis limits [0, 499]
+    Screen: i32[Height, Width] = empty((Height, Width), dtype=int32)
+    Clear(Height, Width, Screen)
+
+    i: i32
+    n: i32 = len(polygon)
+    for i in range(n):
+        Line(Height, Width, Screen, polygon[i][0], polygon[i][1], polygon[(i + 1) % n][0], polygon[(i + 1) % n][1])
+
+    point_size: i32 = 5
+    for i in range(len(points)):
+        Circle(Height, Width, Screen, points[i][0], points[i][1], f64(point_size))
+
+    Display(Height, Width, Screen)
+
+def main0():
+    points: list[tuple[i32, i32]] = [(445, 193), (138, 28), (418, 279), (62, 438), (168, 345), (435, 325), (293, 440), (158, 94), (403, 288), (136, 278), (141, 243), (287, 313), (338, 492), (172, 78), (29, 404), (79, 377), (184, 91), (69, 324), (408, 72), (494, 1)]
+    convex_hull_points: list[tuple[i32, i32]] = convex_hull(points)
+    # print(convex_hull_points)
+    plot_graph(convex_hull_points, points)
+
+    assert convex_hull_points == [(29, 404), (138, 28), (494, 1), (435, 325), (338, 492), (62, 438)]
+
+main0()

integration_tests/test_pkg_lpconvexhull.py

@@ -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/bin/lpython.cpp

@@ -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/ASR.asdl

@@ -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/CMakeLists.txt

@@ -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):