Merge pull request #1606 from harshsingh-24/str-funcs

New string Method `endswith()` support

Author: certik

integration_tests/test_str_attributes.py

@@ -78,6 +78,55 @@ def startswith():
     assert s.startswith("sdd") == False
     assert "".startswith("ok") == False
 
+def endswith():
+
+    # The following test suite fulfils the control flow graph coverage
+    # in terms of Statement Coverage and Branch Coverage associated with endwith() functionality.
+
+    # Case 1: When string is constant and suffix is also constant 
+    assert "".endswith("") == True
+    assert "".endswith(" ") ==  False
+    assert "".endswith("%") == False
+    assert "".endswith("a1234PT#$") == False
+    assert "".endswith("blah blah") == False
+    assert " rendezvous 5:30 ".endswith("") == True
+    assert " rendezvous 5:30 ".endswith(" ") == True
+    assert " rendezvous 5:30 ".endswith(" 5:30 ") == True
+    assert " rendezvous 5:30 ".endswith("apple") == False
+    assert "two plus".endswith("longer than string") == False
+
+
+    # Case 2: When string is constant and suffix is variable
+    suffix: str
+    suffix = ""
+    assert "".endswith(suffix) == True
+    suffix = " "
+    assert "".endswith(suffix) ==  False
+    suffix = "5:30 "
+    assert " rendezvous 5:30 ".endswith(suffix) == True
+    suffix = ""
+    assert " rendezvous 5:30 ".endswith(suffix) == True
+    suffix = "apple"
+    assert " rendezvous 5:30 ".endswith(suffix) == False
+    suffix = "longer than string"
+    assert "two plus".endswith(suffix) == False
+
+    # Case 3: When string is variable and suffix is either constant or variable
+    s: str
+    s = ""
+    assert s.endswith("") == True
+    assert s.endswith("apple") == False
+    assert s.endswith(" ") == False
+    assert s.endswith(suffix) == False
+
+    s = " rendezvous 5 "
+    assert s.endswith(" $3324") == False
+    assert s.endswith("5 ") == True
+    assert s.endswith(s) == True
+    suffix = "vous 5 "
+    assert s.endswith(suffix) == True
+    suffix = "apple"
+    assert s.endswith(suffix) == False
 
 def check():
     capitalize()
@@ -86,5 +135,6 @@ def check():
     swapcase()
     find()
     startswith()
+    endswith()
 
 check()

src/lpython/semantics/python_ast_to_asr.cpp

@@ -5665,13 +5665,13 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             fn_args.push_back(al, arg);
         } else if (attr_name == "startswith") {
             if(args.size() != 1) {
-                throw SemanticError("str.startwith() takes one argument",
+                throw SemanticError("str.startswith() takes one argument",
                         loc);
             }
             ASR::expr_t *arg_sub = args[0].m_value;
             ASR::ttype_t *arg_sub_type = ASRUtils::expr_type(arg_sub);
             if (!ASRUtils::is_character(*arg_sub_type)) {
-                throw SemanticError("str.startwith() takes one argument of type: str",
+                throw SemanticError("str.startswith() takes one argument of type: str",
                         loc);
             }
             fn_call_name = "_lpython_str_startswith";
@@ -5683,6 +5683,38 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
             sub.m_value = args[0].m_value;
             fn_args.push_back(al, str);
             fn_args.push_back(al, sub);
+        } else if (attr_name == "endswith") {
+            /*
+                str.endswith(suffix)     ---->  
+                Return True if the string ends with the specified suffix, otherwise return False.
+
+                arg_sub: Substring argument provided inside endswith() function
+                arg_sub_type: Type of Substring argument
+                fn_call_name: Name of the Function that has logic/implementation of endswith() function
+                str: Associates with string on which endswith() function will act on
+                suffix: Associates with the suffix string which is provided as an argument to endswith() function
+            */
+            if(args.size() != 1) {
+                throw SemanticError("str.endswith() takes only one argument", loc);
+            }
+            ASR::expr_t *arg_suffix = args[0].m_value;
+            ASR::ttype_t *arg_suffix_type = ASRUtils::expr_type(arg_suffix);
+            if (!ASRUtils::is_character(*arg_suffix_type)) {
+                throw SemanticError("str.endswith() takes one argument of type: str", loc);
+            }
+
+            fn_call_name = "_lpython_str_endswith";
+            ASR::call_arg_t str;
+            str.loc = loc;
+            str.m_value = s_var;
+
+            ASR::call_arg_t suffix;
+            suffix.loc = loc;
+            suffix.m_value = args[0].m_value;
+
+            // Push string and substring argument on top of Vector (or Function Arguments Stack basically)
+            fn_args.push_back(al, str);
+            fn_args.push_back(al, suffix);
         } else {
             throw SemanticError("String method not implemented: " + attr_name,
                     loc);
@@ -5874,6 +5906,62 @@ class BodyVisitor : public CommonVisitor<BodyVisitor> {
                         "_lpython_str_startswith", loc);
             }
             return;
+        } else if (attr_name == "endswith") {
+            /* 
+                str.endswith(suffix)     ---->  
+                Return True if the string ends with the specified suffix, otherwise return False.
+            */
+
+            if (args.size() != 1) {
+                throw SemanticError("str.endswith() takes one arguments", loc);
+            }
+
+            ASR::expr_t *arg_suffix = args[0].m_value;
+            ASR::ttype_t *arg_suffix_type = ASRUtils::expr_type(arg_suffix);
+            if (!ASRUtils::is_character(*arg_suffix_type)) {
+                throw SemanticError("str.endswith() takes one arguments of type: str", arg_suffix->base.loc);
+            }
+            
+            if (ASRUtils::expr_value(arg_suffix) != nullptr) {
+                /*
+                    Invoked when Suffix argument is provided as a constant string
+                */
+                ASR::StringConstant_t* suffix_constant = ASR::down_cast<ASR::StringConstant_t>(arg_suffix);
+                std::string suffix = suffix_constant->m_s;
+                
+                bool res = true;
+                if (suffix.size() > s_var.size()) 
+                    res = false;
+                else 
+                    res = std::equal(suffix.rbegin(), suffix.rend(), s_var.rbegin());
+                
+                tmp = ASR::make_LogicalConstant_t(al, loc, res, 
+                    ASRUtils::TYPE(ASR::make_Logical_t(al, loc, 4, nullptr, 0)));
+    
+            } else {
+                /*
+                    Invoked when Suffix argument is provided as a variable
+                    b: str = "ple"
+                    Eg: "apple".endswith(b)
+                */
+                ASR::symbol_t *fn_div = resolve_intrinsic_function(loc, "_lpython_str_endswith");
+                Vec<ASR::call_arg_t> args;
+                args.reserve(al, 1);
+                ASR::call_arg_t str_arg;
+                str_arg.loc = loc;
+                ASR::ttype_t *str_type = ASRUtils::TYPE(ASR::make_Character_t(al, loc,
+                        1, s_var.size(), nullptr, nullptr, 0));
+                str_arg.m_value = ASRUtils::EXPR(
+                        ASR::make_StringConstant_t(al, loc, s2c(al, s_var), str_type));
+                ASR::call_arg_t sub_arg;
+                sub_arg.loc = loc;
+                sub_arg.m_value = arg_suffix;
+                args.push_back(al, str_arg);
+                args.push_back(al, sub_arg);
+
+                tmp = make_call_helper(al, fn_div, current_scope, args, "_lpython_str_endswith", loc);
+            }
+            return;
         } else {
             throw SemanticError("'str' object has no attribute '" + attr_name + "'",
                     loc);

src/lpython/semantics/python_comptime_eval.h

@@ -77,7 +77,8 @@ struct PythonIntrinsicProcedures {
             {"_lpython_str_lstrip", {m_builtin, &not_implemented}},
             {"_lpython_str_strip", {m_builtin, &not_implemented}},
             {"_lpython_str_swapcase", {m_builtin, &not_implemented}},
-            {"_lpython_str_startswith", {m_builtin, &not_implemented}}
+            {"_lpython_str_startswith", {m_builtin, &not_implemented}},
+            {"_lpython_str_endswith", {m_builtin, &not_implemented}}
         };
     }
 

src/runtime/lpython_builtin.py

@@ -775,6 +775,21 @@ def _lpython_str_startswith(s: str ,sub: str) -> bool:
         res = res and (j == len(sub))
     return res
 
+@overload
+def _lpython_str_endswith(s: str, suffix: str) -> bool: 
+
+    if(len(suffix) > len(s)):
+        return False
+    
+    i : i32
+    i = 0
+    while(i < len(suffix)):
+        if(suffix[len(suffix) - i - 1] != s[len(s) - i - 1]):
+            return False
+        i += 1
+        
+    return True
+
 
 def list(s: str) -> list[str]:
     l: list[str] = []

tests/reference/asr-array_01_decl-39cf894.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-array_01_decl-39cf894.stdout",
-    "stdout_hash": "5ecd298c183e6b4027f8f601a2b5d3963033ebf54bca582c982b5929",
+    "stdout_hash": "4377072f8ac3cfc1bd619f53d07542c11dd648fa100d0f3104e1a4c7",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/asr-array_01_decl-39cf894.stdout

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-array_02_decl-e8f6874.stdout",
-    "stdout_hash": "9fcfaf5cb7d6dfd6798902f102d41743c0c6c89180572345d886154f",
+    "stdout_hash": "dd1434de42dcd718f283abd72d736f032846819a9a31585b32a528c0",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0

tests/reference/asr-array_02_decl-e8f6874.json

@@ -6,7 +6,7 @@
     "outfile": null,
     "outfile_hash": null,
     "stdout": "asr-bindc_02-bc1a7ea.stdout",
-    "stdout_hash": "00799f9ef4a45d4c3e93d043b31f73f8038a4b82a4ee191f29b0467f",
+    "stdout_hash": "2e6dbece0d145af97d42a7780c4dd0701c3456381a9761bfb95da91c",
     "stderr": null,
     "stderr_hash": null,
     "returncode": 0