Synchronizing libasr's template instantiation with LFortran (#1474)

* Modified generic tests to not use built-in functions

* Removed TemplateBinOp and built in functions for restrictions

* Fixed generic tests

* Removed comments

* Updated reference tests for generic tests

* Renamed instantiated generic functions so it synchronized with LFortran instantiation

* Updated reference tests again

* Modified generic instantiation's interface to match LFortran

Author: ansharlubis

integration_tests/generics_01.py

@@ -1,17 +1,20 @@
-from ltypes import TypeVar, restriction
+from ltypes import TypeVar, restriction, i32
 
 T = TypeVar('T')
 
 @restriction
 def add(x: T, y: T) -> T:
     pass
 
+def add_integer(x: i32, y: i32) -> i32:
+    return x + y
+
 def add_string(x: str, y: str) -> str:
     return x + y
 
 def f(x: T, y: T, **kwargs) -> T:
     return add(x,y)
 
-print(f(1,2))
+print(f(1, 2, add=add_integer))
 print(f("a","b",add=add_string))
 print(f("c","d",add=add_string))

integration_tests/generics_array_01.py

@@ -1,4 +1,4 @@
-from ltypes import TypeVar
+from ltypes import TypeVar, i32
 from numpy import empty
 
 T = TypeVar('T')

integration_tests/generics_array_02.py

@@ -9,7 +9,13 @@
 def add(x: T, y: T) -> T:
     pass
 
-def g(n: i32, a: T[n], b: T[n]):
+def add_integer(x: i32, y: i32) -> i32:
+    return x + y
+
+def add_float(x: f32, y: f32) -> f32:
+    return x + y
+
+def g(n: i32, a: T[n], b: T[n], **kwargs):
   r: T[n]
   r = empty(n)
   i: i32
@@ -22,11 +28,11 @@ def main():
     a_int[0] = 400
     b_int: i32[1] = empty(1)
     b_int[0] = 20
-    g(1, a_int, b_int)
+    g(1, a_int, b_int, add=add_integer)
     a_float: f32[1] = empty(1)
     a_float[0] = f32(400.0)
     b_float: f32[1] = empty(1)
     b_float[0] = f32(20.0)
-    g(1, a_float ,b_float)
+    g(1, a_float, b_float, add=add_float)
 
 main()

integration_tests/generics_array_03.py

@@ -11,7 +11,13 @@
 def add(x: T, y: T) -> T:
     pass
 
-def g(n: i32, m: i32, a: T[n,m], b: T[n,m]) -> T[n,m]:
+def add_integer(x: i32, y: i32) -> i32:
+    return x + y
+
+def add_float(x: f32, y: f32) -> f32:
+    return x + y
+
+def g(n: i32, m: i32, a: T[n,m], b: T[n,m], **kwargs) -> T[n,m]:
     r: T[n,m]
     r = empty([n,m])
     i: i32
@@ -26,11 +32,11 @@ def main():
     a_int[0,0] = 400
     b_int: i32[1,1] = empty([1,1])
     b_int[0,0] = 20
-    g(1, 1, a_int, b_int)
-    a_float: i32[1,1] = empty([1,1])
-    a_float[0,0] = 400
-    b_float: i32[1,1] = empty([1,1])
-    b_float[0,0] = 20
-    g(1, 1, a_float, b_float)
+    g(1, 1, a_int, b_int, add=add_integer)
+    a_float: f32[1,1] = empty([1,1])
+    a_float[0,0] = f32(400)
+    b_float: f32[1,1] = empty([1,1])
+    b_float[0,0] = f32(20)
+    g(1, 1, a_float, b_float, add=add_float)
 
 main()

integration_tests/generics_list_01.py

@@ -14,6 +14,24 @@ def add(x: T, y: T) -> T:
 def div(x: T, k: i32) -> f64:
     pass
 
+def empty_integer(x: i32) -> i32:
+    return 0
+
+def add_integer(x: i32, y: i32) -> i32:
+    return x + y
+
+def div_integer(x: i32, k: i32) -> f64:
+    return x / k
+
+def empty_float(x: f64) -> f64:
+    return 0.0
+
+def add_float(x: f64, y: f64) -> f64:
+    return x + y
+
+def div_float(x: f64, k: i32) -> f64:
+    return x / k
+
 def empty_string(x: str) -> str:
     return ""
 
@@ -34,6 +52,6 @@ def mean(x: list[T], **kwargs) -> f64:
         res = add(res, x[i])
     return div(res, k)
 
-print(mean([1,2,3]))
-print(mean([1.0,2.0,3.0]))
+print(mean([1,2,3], zero=empty_integer, add=add_integer, div=div_integer))
+print(mean([1.0,2.0,3.0], zero=empty_float, add=add_float, div=div_float))
 print(mean(["a","b","c"], zero=empty_string, add=add_string, div=div_string))

src/libasr/ASR.asdl

@@ -249,7 +249,6 @@ expr
     | LogicalNot(expr arg, ttype type, expr? value)
     | LogicalCompare(expr left, cmpop op, expr right, ttype type, expr? value)
     | LogicalBinOp(expr left, logicalbinop op, expr right, ttype type, expr? value)
-    | TemplateBinOp(expr left, binop op, expr right, ttype type, expr? value)
 
     | ListConstant(expr* args, ttype type)
     | ListLen(expr arg, ttype type, expr? value)

src/libasr/pass/instantiate_template.cpp

@@ -204,12 +204,6 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicator<FunctionInstanti
         return ASR::make_Assignment_t(al, x->base.base.loc, target, value, overloaded);
     }
 
-    ASR::asr_t* duplicate_TemplateBinOp(ASR::TemplateBinOp_t *x) {
-        ASR::expr_t *left = duplicate_expr(x->m_left);
-        ASR::expr_t *right = duplicate_expr(x->m_right);
-        return make_BinOp_helper(left, right, x->m_op, x->base.base.loc);
-    }
-
     ASR::asr_t* duplicate_DoLoop(ASR::DoLoop_t *x) {
         Vec<ASR::stmt_t*> m_body;
         m_body.reserve(al, x->n_body);
@@ -249,39 +243,10 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicator<FunctionInstanti
         ASR::expr_t* value = duplicate_expr(x->m_value);
         ASR::expr_t* dt = duplicate_expr(x->m_dt);
         std::string call_name = ASRUtils::symbol_name(x->m_name);
-        if ((name && ASRUtils::is_restriction_function(name) && rt_subs.find(call_name) == rt_subs.end()) ||
-            !name) {
-            if (call_name.compare("add") == 0) {
-                ASR::expr_t* left_arg = duplicate_expr(x->m_args[0].m_value);
-                ASR::expr_t* right_arg = duplicate_expr(x->m_args[1].m_value);
-                ASR::ttype_t* left_type = substitute_type(ASRUtils::expr_type(left_arg));
-                ASR::ttype_t* right_type = substitute_type(ASRUtils::expr_type(right_arg));
-                if ((ASRUtils::is_integer(*left_type) && ASRUtils::is_integer(*right_type)) ||
-                        (ASRUtils::is_real(*left_type) && ASRUtils::is_real(*right_type))) {
-                    return make_BinOp_helper(left_arg, right_arg, ASR::binopType::Add, x->base.base.loc);
-                } else {
-                    throw SemanticError("Intrinsic plus not yet supported for this type", x->base.base.loc);
-                }
-            } else if (call_name.compare("zero") == 0) {
-                ASR::expr_t* arg = duplicate_expr(x->m_args[0].m_value);
-                ASR::ttype_t* arg_type = substitute_type(ASRUtils::expr_type(arg));
-                if (ASRUtils::is_integer(*arg_type)) {
-                    return ASR::make_IntegerConstant_t(al, x->base.base.loc, 0, arg_type);
-                } else if (ASRUtils::is_real(*arg_type)) {
-                    return ASR::make_RealConstant_t(al, x->base.base.loc, 0, arg_type);
-                }
-            } else if (call_name.compare("div") == 0) {
-                ASR::expr_t* left_arg = duplicate_expr(x->m_args[0].m_value);
-                ASR::expr_t* right_arg = duplicate_expr(x->m_args[1].m_value);
-                return make_BinOp_helper(left_arg, right_arg, ASR::binopType::Div, x->base.base.loc);
-            }
-            LCOMPILERS_ASSERT(false); // should never happen
-            name = rt_subs[call_name];
-        }
         if (ASRUtils::is_restriction_function(name)) {
             name = rt_subs[call_name];
         } else if (ASRUtils::is_generic_function(name)) {
-            std::string nested_func_name = "__lfortran_generic_" + sym_name;
+            std::string nested_func_name = "__asr_generic_" + sym_name;
             ASR::symbol_t* name2 = ASRUtils::symbol_get_past_external(name);
             ASR::Function_t* func = ASR::down_cast<ASR::Function_t>(name2);
             FunctionInstantiator nested_tf(al, subs, rt_subs, func_scope, nested_func_name);
@@ -425,7 +390,7 @@ class FunctionInstantiator : public ASR::BaseExprStmtDuplicator<FunctionInstanti
 };
 
 ASR::symbol_t* pass_instantiate_generic_function(Allocator &al, std::map<std::string, ASR::ttype_t*> subs,
-        std::map<std::string, ASR::symbol_t*>& rt_subs, SymbolTable *current_scope,
+        std::map<std::string, ASR::symbol_t*> rt_subs, SymbolTable *current_scope,
         std::string new_func_name, ASR::symbol_t *sym) {
     ASR::symbol_t* sym2 = ASRUtils::symbol_get_past_external(sym);
     ASR::Function_t* func = ASR::down_cast<ASR::Function_t>(sym2);
@@ -434,12 +399,4 @@ ASR::symbol_t* pass_instantiate_generic_function(Allocator &al, std::map<std::st
     return ASR::down_cast<ASR::symbol_t>(new_function);
 }
 
-ASR::symbol_t* pass_instantiate_generic_function(Allocator &al, std::map<std::string, ASR::ttype_t*> subs,
-        std::map<std::string, ASR::symbol_t*>& rt_subs, SymbolTable *current_scope,
-        std::string new_func_name, ASR::Function_t *func) {
-    FunctionInstantiator tf(al, subs, rt_subs, current_scope, new_func_name);
-    ASR::asr_t *new_function = tf.instantiate_Function(func);
-    return ASR::down_cast<ASR::symbol_t>(new_function);
-}
-
 } // namespace LCompilers

src/libasr/pass/instantiate_template.h

@@ -11,12 +11,8 @@ namespace LCompilers {
      *        is executed here
      */
     ASR::symbol_t* pass_instantiate_generic_function(Allocator &al,
-        std::map<std::string, ASR::ttype_t*> subs, std::map<std::string, ASR::symbol_t*>& rt_subs,
+        std::map<std::string, ASR::ttype_t*> subs, std::map<std::string, ASR::symbol_t*> rt_subs,
         SymbolTable *current_scope, std::string new_func_name, ASR::symbol_t *sym);
-
-    ASR::symbol_t* pass_instantiate_generic_function(Allocator &al,
-        std::map<std::string, ASR::ttype_t*> subs, std::map<std::string, ASR::symbol_t*>& rt_subs,
-        SymbolTable *current_scope, std::string new_func_name, ASR::Function_t *sym);
 }
 
 #endif // LFORTRAN_PASS_TEMPLATE_VISITOR_H

src/libasr/runtime/lfortran_intrinsics.c

@@ -1304,7 +1304,7 @@ char *get_base_name(char *filename) {
 
 #ifdef HAVE_LFORTRAN_LINK
 int shared_lib_callback(struct dl_phdr_info *info,
-        size_t /* size */, void *_data) {
+        size_t size, void *_data) {
     struct Stacktrace *d = (struct Stacktrace *) _data;
     for (int i = 0; i < info->dlpi_phnum; i++) {
         if (info->dlpi_phdr[i].p_type == PT_LOAD) {

src/lpython/semantics/python_ast_to_asr.cpp

@@ -1062,7 +1062,8 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
                     check_type_restriction(subs, rt_subs, rt, loc);
                 }
 
-                ASR::symbol_t *t = get_generic_function(subs, rt_subs, func);
+                //ASR::symbol_t *t = get_generic_function(subs, rt_subs, func);
+                ASR::symbol_t *t = get_generic_function(subs, rt_subs, s);
                 std::string new_call_name = (ASR::down_cast<ASR::Function_t>(t))->m_name;
 
                 // Currently ignoring keyword arguments for generic function calls
@@ -1336,14 +1337,14 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
      *        arguments. If not, then instantiate a new function.
      */
     ASR::symbol_t* get_generic_function(std::map<std::string, ASR::ttype_t*> subs,
-            std::map<std::string, ASR::symbol_t*>& rt_subs, ASR::Function_t *func) {
+            std::map<std::string, ASR::symbol_t*>& rt_subs, ASR::symbol_t *func) {
         int new_function_num;
         ASR::symbol_t *t;
-        std::string func_name = func->m_name;
+        std::string func_name = ASRUtils::symbol_name(func);
         if (generic_func_nums.find(func_name) != generic_func_nums.end()) {
             new_function_num = generic_func_nums[func_name];
             for (int i=0; i<generic_func_nums[func_name]; i++) {
-                std::string generic_func_name = "__lpython_generic_" + func_name + "_" + std::to_string(i);
+                std::string generic_func_name = "__asr_generic_" + func_name + "_" + std::to_string(i);
                 if (generic_func_subs.find(generic_func_name) != generic_func_subs.end()) {
                     std::map<std::string, ASR::ttype_t*> subs_check = generic_func_subs[generic_func_name];
                     if (subs_check.size() != subs.size()) { continue; }
@@ -1368,11 +1369,11 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
             new_function_num = 0;
         }
         generic_func_nums[func_name] = new_function_num + 1;
-        std::string new_func_name = "__lpython_generic_" + func_name + "_"
+        std::string new_func_name = "__asr_generic_" + func_name + "_"
             + std::to_string(new_function_num);
         generic_func_subs[new_func_name] = subs;
-        t = pass_instantiate_generic_function(al, subs, rt_subs, func->m_symtab->parent,
-                new_func_name, func);
+        t = pass_instantiate_generic_function(al, subs, rt_subs, 
+            ASRUtils::symbol_parent_symtab(func), new_func_name, func);
         dependencies.erase(func_name);
         dependencies.insert(new_func_name);
         return t;
@@ -2105,8 +2106,6 @@ class CommonVisitor : public AST::BaseVisitor<Struct> {
 
             tmp = ASR::make_ComplexBinOp_t(al, loc, left, op, right, dest_type, value);
 
-        } else if (ASRUtils::is_generic(*dest_type)) {
-            tmp = ASR::make_TemplateBinOp_t(al, loc, left, op, right, dest_type, value);
         }
 
 

tests/reference/asr-generics_01-d616074.json

@@ -2,11 +2,11 @@
     "basename": "asr-generics_01-d616074",
     "cmd": "lpython --show-asr --no-color {infile} -o {outfile}",
     "infile": "tests/../integration_tests/generics_01.py",
-    "infile_hash": "457bb6166206ba1f310ff7879cf0f56a00c50162f6f4fe3f376af6ee",
+    "infile_hash": "cf91399f0cae8a099eec7af56ef12bc0f52e60599f0971baf5e001b5",
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-generics_01-d616074.stdout",
-    "stdout_hash": "3639281a76fe0e25dc0c22bde4e8393f4c84e82d78ca370da6b50ffe",
+    "stdout_hash": "83f0370d5dd0478c47e8c976c294dcde303ee66be912941e4f69c41e",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0