Make sure we replace only modifiers

Edit regex and replace to consider word boundaries

Author: gnikit

fortls/parse_fortran.py

@@ -314,8 +314,7 @@ def read_fun_def(
     # Get all the keyword modifier mathces
     keywords = re.findall(SUB_MOD_REGEX, line)
     # remove modifiers from line
-    for modifier in keywords:
-        line = line.replace(modifier, "")
+    line = re.sub(SUB_MOD_REGEX, "", line)
 
     # Try and get the result type
     # Recursively will call read_var_def which will then call read_fun_def
@@ -353,12 +352,10 @@ def read_fun_def(
 
 def read_sub_def(line: str, mod_flag: bool = False):
     """Attempt to read SUBROUTINE definition line"""
-    keywords: list[str] = []
-    mod_match = SUB_MOD_REGEX.match(line)
-    while mod_match is not None:
-        line = line[mod_match.end(0) :]
-        keywords.append(mod_match.group(1))
-        mod_match = SUB_MOD_REGEX.match(line)
+    # Get all the keyword modifier mathces
+    keywords = re.findall(SUB_MOD_REGEX, line)
+    # remove modifiers from line
+    line = re.sub(SUB_MOD_REGEX, "", line)
     sub_match = SUB_REGEX.match(line)
     if sub_match is None:
         return None

fortls/regex_patterns.py

@@ -11,7 +11,7 @@
 INCLUDE_REGEX = re.compile(r"[ ]*INCLUDE[ :]*[\'\"]([^\'\"]*)", re.I)
 CONTAINS_REGEX = re.compile(r"[ ]*(CONTAINS)[ ]*$", re.I)
 IMPLICIT_REGEX = re.compile(r"[ ]*IMPLICIT[ ]+([a-z]*)", re.I)
-SUB_MOD_REGEX = re.compile(r"[ ]*(PURE|IMPURE|ELEMENTAL|RECURSIVE)+", re.I)
+SUB_MOD_REGEX = re.compile(r"[ ]*\b(PURE|IMPURE|ELEMENTAL|RECURSIVE)\b", re.I)
 SUB_REGEX = re.compile(r"[ ]*SUBROUTINE[ ]+([a-z0-9_]+)", re.I)
 END_SUB_REGEX = re.compile(r"SUBROUTINE", re.I)
 FUN_REGEX = re.compile(r"[ ]*FUNCTION[ ]+([a-z0-9_]+)", re.I)

test/test_server.py

@@ -579,6 +579,8 @@ def check_return(result_array, checks):
     string += hover_req(file_path, 12, 12)
     string += hover_req(file_path, 18, 19)
     string += hover_req(file_path, 23, 34)
+    file_path = test_dir / "hover" / "recursive.f90"
+    string += hover_req(file_path, 9, 40)
     file_path = test_dir / "subdir" / "test_submod.F90"
     string += hover_req(file_path, 29, 24)
     string += hover_req(file_path, 34, 24)
@@ -615,6 +617,10 @@ def check_return(result_array, checks):
         # any modifiers before the type would be discarded
         """INTEGER PURE ELEMENTAL FUNCTION fun5(arg) RESULT(retval)
  INTEGER, INTENT(IN) :: arg""",
+        """RECURSIVE SUBROUTINE recursive_assign_descending(node, vector, current_loc)
+ TYPE(tree_inode), POINTER, INTENT(IN) :: node
+ INTEGER, DIMENSION(:), INTENT(INOUT) :: vector
+ INTEGER, INTENT(INOUT) :: current_loc""",
         # TODO: more tests to add from functions
         """REAL FUNCTION point_dist(a, b) RESULT(distance)
  TYPE(point), INTENT(IN) :: a
@@ -746,6 +752,11 @@ def check_return(results, ref_results):
     string += write_rpc_notification(
         "textDocument/didOpen", {"textDocument": {"uri": file_path}}
     )
+    # Test module procedure in submodules importing scopes
+    file_path = str(test_dir / "subdir" / "test_submod.f90")
+    string += write_rpc_notification(
+        "textDocument/didOpen", {"textDocument": {"uri": file_path}}
+    )
     errcode, results = run_request(string)
     assert errcode == 0
 
@@ -815,6 +826,7 @@ def check_return(results, ref_results):
         [],
         [],
         [],
+        [],
         [
             {
                 "range": {

test/test_source/hover/recursive.f90

@@ -0,0 +1,23 @@
+module tree
+    type tree_inode
+        integer :: value = 0
+        type (tree_inode), pointer :: left=>null()
+        type (tree_inode), pointer :: right=>null()
+        type (tree_inode), pointer :: parent=>null()
+    end type tree_inode
+
+contains
+    recursive subroutine recursive_assign_descending(node, vector, current_loc)
+        type(tree_inode), pointer, intent(in) :: node
+        integer, dimension(:), intent(inout)  :: vector
+        integer, intent(inout)                :: current_loc
+
+        if (associated(node)) then
+            call recursive_assign_descending(node%right, vector, current_loc)
+            vector(current_loc) = node%value
+            current_loc = current_loc + 1
+            call recursive_assign_descending(node%left, vector, current_loc)
+        end if
+        return
+    end subroutine recursive_assign_descending
+end module tree