Implement goto in LPython

integration_tests/CMakeLists.txt

@@ -275,6 +275,7 @@ RUN(NAME generics_list_01    LABELS cpython llvm)
 RUN(NAME test_statistics     LABELS cpython llvm)
 RUN(NAME test_str_attributes LABELS cpython llvm)
 RUN(NAME kwargs_01           LABELS cpython llvm)
+RUN(NAME test_01_goto        LABELS cpython llvm c)
 
 RUN(NAME func_inline_01 LABELS llvm wasm)
 RUN(NAME func_static_01 LABELS cpython llvm c wasm)

integration_tests/test_01_goto.py

@@ -0,0 +1,35 @@
+from ltypes import with_goto, i32
+
+@with_goto
+def f() -> i32:
+    i:i32
+    for i in range(10):
+        if i == 5:
+            goto .end
+
+    label .end
+    assert i == 5
+    return i
+
+@with_goto
+def g(size: i32) -> i32:
+    i:i32
+
+    i = 0
+    label .loop
+    if i >= size:
+        goto .end
+    i += 1
+    goto .loop
+
+    label .end
+    return i
+
+def test_goto():
+    print(f())
+    print(g(10))
+    print(g(20))
+    assert g(30) == 30
+    assert g(40) == 40
+
+test_goto()

src/libasr/ASR.asdl

@@ -173,10 +173,10 @@ stmt
         -- GoTo points to a GoToTarget with the corresponding target_id within
         -- the same procedure. We currently use `int` IDs to link GoTo with
         -- GoToTarget to avoid issues with serialization.
-    | GoTo(int target_id)
+    | GoTo(int target_id, identifier name)
         -- An empty statement, a target of zero or more GoTo statements
         -- the `id` is only unique within a procedure
-    | GoToTarget(int id)
+    | GoToTarget(int id, identifier name)
     | If(expr test, stmt* body, stmt* orelse)
     | IfArithmetic(expr test, int lt_label, int eq_label, int gt_label)
     | Print(expr? fmt, expr* values, expr? separator, expr? end)

src/libasr/asr_utils.h

@@ -1746,7 +1746,8 @@ class ReplaceReturnWithGotoVisitor: public ASR::BaseStmtReplacer<ReplaceReturnWi
     }
 
     void replace_Return(ASR::Return_t* x) {
-        *current_stmt = ASRUtils::STMT(ASR::make_GoTo_t(al, x->base.base.loc, goto_label));
+        *current_stmt = ASRUtils::STMT(ASR::make_GoTo_t(al, x->base.base.loc, goto_label,
+                            s2c(al, "__" + std::to_string(goto_label))));
         has_replacement_happened = true;
     }
 

src/libasr/codegen/asr_to_c.cpp

@@ -1126,6 +1126,14 @@ R"(
         src = "strlen(" + src + ")";
     }
 
+    void visit_GoTo(const ASR::GoTo_t &x) {
+        std::string indent(indentation_level*indentation_spaces, ' ');
+        src =  indent + "goto " + std::string(x.m_name) + ";\n";
+    }
+
+    void visit_GoToTarget(const ASR::GoToTarget_t &x) {
+        src = std::string(x.m_name) + ":\n";
+    }
 };
 
 Result<std::string> asr_to_c(Allocator &al, ASR::TranslationUnit_t &asr,

src/lpython/semantics/python_ast_to_asr.cpp

@@ -1,6 +1,7 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <set>
 #include <memory>
 #include <string>
 #include <cmath>
@@ -2843,7 +2844,6 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
         bool current_procedure_interface = false;
         bool overload = false;
         bool vectorize = false, is_inline = false, is_static = false;
-
         Vec<ASR::ttype_t*> tps;
         tps.reserve(al, x.m_args.n_args);
         bool is_restriction = false;
@@ -2866,6 +2866,8 @@ class SymbolTableVisitor : public CommonVisitor<SymbolTableVisitor> {
                         vectorize = true;
                     } else if (name == "restriction") {
                         is_restriction = true;
+                    } else if (name == "with_goto") {
+                        // TODO: Use goto attribute in function?
                     } else if (name == "inline") {
                         is_inline = true;
                     } else if (name == "static") {
@@ -3211,11 +3213,14 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
 
 public:
     ASR::asr_t *asr;
+    std::map<std::string, std::tuple<int64_t, bool, Location>> goto_name2id;
+    int64_t gotoids;
 
 
     BodyVisitor(Allocator &al, ASR::asr_t *unit, diag::Diagnostics &diagnostics,
          bool main_module, std::map<int, ASR::symbol_t*> &ast_overload)
-         : CommonVisitor(al, nullptr, diagnostics, main_module, ast_overload, ""), asr{unit}
+         : CommonVisitor(al, nullptr, diagnostics, main_module, ast_overload, ""), asr{unit},
+         gotoids{0}
          {}
 
     // Transforms statements to a list of ASR statements
@@ -3300,6 +3305,8 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
     }
 
     void visit_FunctionDef(const AST::FunctionDef_t &x) {
+        goto_name2id.clear();
+        gotoids = 0;
         SymbolTable *old_scope = current_scope;
         ASR::symbol_t *t = current_scope->get_symbol(x.m_name);
         if (ASR::is_a<ASR::Function_t>(*t)) {
@@ -3320,6 +3327,13 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
         }
         current_scope = old_scope;
         tmp = nullptr;
+
+        for( auto itr: goto_name2id ) {
+            if( !std::get<1>(itr.second) ) {
+                throw SemanticError("Label '" + itr.first + "' is not defined in '"
+                                    + std::string(x.m_name) + "'", std::get<2>(itr.second));
+            }
+        }
     }
 
     void visit_Import(const AST::Import_t &/*x*/) {
@@ -3969,7 +3983,36 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
     void visit_Attribute(const AST::Attribute_t &x) {
         if (AST::is_a<AST::Name_t>(*x.m_value)) {
             std::string value = AST::down_cast<AST::Name_t>(x.m_value)->m_id;
+            if( value == "label" ) {
+                std::string labelname = x.m_attr;
+                if( goto_name2id.find(labelname) == goto_name2id.end() ) {
+                    goto_name2id[labelname] = std::make_tuple(gotoids, true, x.base.base.loc);
+                    gotoids += 1;
+                } else if( !std::get<1>(goto_name2id[labelname]) ) {
+                    goto_name2id[labelname] = std::make_tuple(
+                        std::get<0>(goto_name2id[labelname]),
+                        true,
+                        std::get<2>(goto_name2id[labelname])
+                    );
+                }
+                int id = std::get<0>(goto_name2id[labelname]);
+                tmp = ASR::make_GoToTarget_t(al, x.base.base.loc, id, x.m_attr);
+                return ;
+            }
+
+             if (value == "goto"){
+                std::string labelname = std::string(x.m_attr);
+                if( goto_name2id.find(labelname) == goto_name2id.end() ) {
+                    goto_name2id[labelname] = std::make_tuple(gotoids, false, x.base.base.loc);
+                    gotoids += 1;
+                }
+                int id = std::get<0>(goto_name2id[labelname]);
+                tmp = ASR::make_GoTo_t(al, x.base.base.loc, id, x.m_attr);
+                return ;
+            }
+
             ASR::symbol_t *t = current_scope->resolve_symbol(value);
+
             if (!t) {
                 throw SemanticError("'" + value + "' is not defined in the scope",
                     x.base.base.loc);
@@ -4543,8 +4586,14 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             return;
         }
         this->visit_expr(*x.m_value);
-        ASRUtils::EXPR(tmp);
-        tmp = nullptr;
+
+        // If tmp is a statement and not an expression
+        // never cast into expression using ASRUtils::EXPR
+        // Just ignore and exit the function naturally.
+        if( !ASR::is_a<ASR::stmt_t>(*tmp) ) {
+            LFORTRAN_ASSERT(ASR::is_a<ASR::expr_t>(*tmp));
+            tmp = nullptr;
+        }
     }