Fixes function modifiers not displaying on hover

It required major rewrite of the function definition parsing

Closes Functions with multiple keywords display incorrect hover #48

TODO:
1. Add tests about intrinsic functions
2. Add tests about functions returning arrays (this is actually a big deal)

2. touches on if hover should be displaying FORTRAN abiding code.
I am leaning towards yes, so displaying
```fortran
real dimension(10,10) function foo(arg) result(val)
  real, intent(in) :: arg
```
Does not seem the right thing for me to do. I think the hover request
should return instead
```fortran
real function foo(arg) result(val)
  real, intent(in) :: arg
  real, dimension(10,10) :: val
```

This way syntax highlighting in VSCode will not complain

Author: gnikit

CHANGELOG.md

@@ -8,6 +8,8 @@
   ([gnikit/fortls#22](https://github.com/gnikit/fortls/issues/22))
 - Fixed function hovering signature now standardised
   ([#47](https://github.com/hansec/fortran-language-server/issues/47))
+- Fixed function modifiers not displaying upon hover
+  ([gnikit/fortls#48](https://github.com/gnikit/fortls/issues/48))
 
 ## 2.2.1
 

fortls/constants.py

@@ -1,5 +1,8 @@
+from __future__ import annotations
+
 import logging
 import sys
+from dataclasses import dataclass, field
 
 PY3K = sys.version_info >= (3, 0)
 
@@ -58,3 +61,23 @@
 # it cannot also be a comment that requires !, c, d
 # and ^= (xor_eq) operator is invalid in Fortran C++ preproc
 FORTRAN_LITERAL = "0^=__LITERAL_INTERNAL_DUMMY_VAR_"
+
+
+@dataclass
+class RESULT_sig:
+    name: str = field(default=None)
+    type: str = field(default=None)
+    keywords: list[str] = field(default_factory=list)
+
+
+@dataclass
+class FUN_sig:
+    name: str
+    args: str
+    keywords: list[str] = field(default_factory=list)
+    mod_flag: bool = field(default=False)
+    result: RESULT_sig = field(default_factory=RESULT_sig)
+
+    def __post_init__(self):
+        if not self.result.name:
+            self.result.name = self.name

fortls/intrinsics.py

@@ -117,7 +117,9 @@ def create_object(json_obj, enc_obj=None):
                 0,
                 name,
                 args=args,
-                result_type=[json_obj["return"], keywords, keyword_info],
+                result_type=json_obj["return"],
+                keywords=keywords,
+                # keyword_info=keyword_info,
             )
         elif json_obj["type"] == 3:
             return fortran_var(

fortls/objects.py

@@ -1087,7 +1087,7 @@ def __init__(
         args: str = "",
         mod_flag: bool = False,
         keywords: list = None,
-        result_type: list[str] = None,  # TODO: make this a string
+        result_type: str = None,
         result_name: str = None,
     ):
         super().__init__(file_ast, line_number, name, args, mod_flag, keywords)
@@ -1098,10 +1098,8 @@ def __init__(
         self.missing_args: list = []
         self.mod_scope: bool = mod_flag
         self.result_name: str = result_name
-        self.result_type: str = None
+        self.result_type: str = result_type
         self.result_obj: fortran_var = None
-        if result_type:
-            self.result_type = result_type[0]
         # Set the implicit result() name to be the function name
         if self.result_name is None:
             self.result_name = self.name

fortls/parse_fortran.py

@@ -5,13 +5,16 @@
 import os
 import re
 import sys
+from typing import Literal
 
 from fortls.constants import (
     DO_TYPE_ID,
     INTERFACE_TYPE_ID,
     PY3K,
     SELECT_TYPE_ID,
     SUBMODULE_TYPE_ID,
+    FUN_sig,
+    RESULT_sig,
     log,
 )
 from fortls.helper_functions import (
@@ -27,7 +30,6 @@
 )
 from fortls.objects import (
     CLASS_info,
-    FUN_info,
     GEN_info,
     INT_info,
     SELECT_info,
@@ -266,8 +268,8 @@ def read_var_def(line: str, type_word: str = None, fun_only: bool = False):
             return None
     #
     keywords, trailing_line = parse_var_keywords(trailing_line)
-    # Check if function
-    fun_def = read_fun_def(trailing_line, [type_word, keywords])
+    # Check if this is a function definition
+    fun_def = read_fun_def(trailing_line, RESULT_sig(type=type_word, keywords=keywords))
     if (fun_def is not None) or fun_only:
         return fun_def
     #
@@ -287,34 +289,42 @@ def read_var_def(line: str, type_word: str = None, fun_only: bool = False):
     return "var", VAR_info(type_word, keywords, var_words)
 
 
-def read_fun_def(line: str, result_type=None, mod_flag: bool = False):
+def read_fun_def(
+    line: str, result: RESULT_sig = RESULT_sig(), mod_flag: bool = False
+) -> tuple[Literal["fun"], FUN_sig] | None:
     """Attempt to read FUNCTION definition line
 
+    To infer the `result` `type` and `name` the variable definition is called
+    with the function only flag
+
     Parameters
     ----------
     line : str
         file line
-    result_type : str, optional
-        type of function e.g. INTEGER, REAL, etc., by default None
+    result : RESULT_sig, optional
+        a dataclass containing the result signature of the function
     mod_flag : bool, optional
         flag for module and module procedure parsing, by default False
 
     Returns
     -------
-    tuple[Literal['fun'], FUN_info]
+    tuple[Literal["fun"], FUN_sig] | None
         a named tuple
     """
-    mod_match = SUB_MOD_REGEX.match(line)
-    mods_found = False
-    keywords: list[str] = []
-    while mod_match is not None:
-        mods_found = True
-        line = line[mod_match.end(0) :]
-        keywords.append(mod_match.group(1))
-        mod_match = SUB_MOD_REGEX.match(line)
-    if mods_found:
+    # 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, "")
+
+    # Try and get the result type
+    # Recursively will call read_var_def which will then call read_fun_def
+    # with the variable result having been populated
+    if keywords:
         tmp_var = read_var_def(line, fun_only=True)
         if tmp_var is not None:
+            # Update keywords for function into dataclass
+            tmp_var[1].keywords = keywords
             return tmp_var
     fun_match = FUN_REGEX.match(line)
     if fun_match is None:
@@ -334,12 +344,11 @@ def read_fun_def(line: str, result_type=None, mod_flag: bool = False):
         trailing_line = trailing_line[paren_match.end(0) :]
 
     # Extract if possible the variable name of the result()
-    result_name = None
     trailing_line = trailing_line.strip()
     results_match = RESULT_REGEX.match(trailing_line)
     if results_match:
-        result_name = results_match.group(1).strip().lower()
-    return "fun", FUN_info(name, args, result_type, result_name, mod_flag, keywords)
+        result.name = results_match.group(1).strip().lower()
+    return "fun", FUN_sig(name, args, keywords, mod_flag, result=result)
 
 
 def read_sub_def(line: str, mod_flag: bool = False):
@@ -548,7 +557,8 @@ def read_mod_def(line: str):
             return sub_res
         fun_res = read_var_def(trailing_line, fun_only=True)
         if fun_res is not None:
-            return fun_res[0], fun_res[1]._replace(mod_flag=True)
+            fun_res[1].mod_flag = True
+            return fun_res[0], fun_res[1]
         fun_res = read_fun_def(trailing_line, mod_flag=True)
         if fun_res is not None:
             return fun_res
@@ -1787,24 +1797,21 @@ def parser_debug_msg(msg: str, line: str, ln: int):
                 args=obj_info.args,
                 mod_flag=obj_info.mod_flag,
                 keywords=keywords,
-                result_type=obj_info.return_type,
-                result_name=obj_info.return_var,
+                result_type=obj_info.result.type,
+                result_name=obj_info.result.name,
             )
             file_ast.add_scope(new_fun, END_FUN_REGEX)
             # function type is present without result(), register the automatic
             # result() variable that is the function name
-            if obj_info.return_type:
-                result_name = obj_info.name
-                if obj_info.return_var:
-                    result_name = obj_info.return_var
-                keywords, keyword_info = map_keywords(obj_info.return_type[1])
+            if obj_info.result.type:
+                keywords, keyword_info = map_keywords(obj_info.result.keywords)
                 new_obj = fortran_var(
                     file_ast,
                     line_number,
-                    result_name,
-                    obj_info.return_type[0],
-                    keywords,
-                    keyword_info,
+                    name=obj_info.result.name,
+                    var_desc=obj_info.result.type,
+                    keywords=keywords,
+                    keyword_info=keyword_info,
                 )
                 file_ast.add_variable(new_obj)
             parser_debug_msg("FUNCTION", line, line_number)

test/test_server.py

@@ -578,8 +578,10 @@ def check_return(result_array, checks):
     string += hover_req(file_path, 7, 19)
     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 / "subdir" / "test_submod.F90"
     string += hover_req(file_path, 29, 24)
+    string += hover_req(file_path, 34, 24)
     file_path = test_dir / "test_diagnostic_int.f90"
     string += hover_req(file_path, 19, 14)
 
@@ -608,8 +610,17 @@ def check_return(result_array, checks):
  INTEGER, INTENT(IN) :: arg""",
         """INTEGER FUNCTION fun4(arg) RESULT(retval)
  INTEGER, INTENT(IN) :: arg""",
+        # Notice that the order of the modifiers does not match the source code
+        # This is part of the test, ideally they would be identical but previously
+        # any modifiers before the type would be discarded
+        """INTEGER PURE ELEMENTAL FUNCTION fun5(arg) RESULT(retval)
+ INTEGER, INTENT(IN) :: arg""",
+        # TODO: more tests to add from functions
         """REAL FUNCTION point_dist(a, b) RESULT(distance)
  TYPE(point), INTENT(IN) :: a
+ TYPE(point), INTENT(IN) :: b""",
+        """LOGICAL FUNCTION is_point_equal_a(a, b) RESULT(is_point_equal_a)
+ TYPE(point), INTENT(IN) :: a
  TYPE(point), INTENT(IN) :: b""",
         """REAL FUNCTION foo2(f, g, h) RESULT(arg3)
  REAL FUNCTION f(x) RESULT(z) :: f

test/test_source/hover/functions.f90

@@ -19,3 +19,9 @@ end function fun3
 integer function fun4(arg) result(retval)
     integer, intent(in) :: arg
 end function fun4
+
+! function with type on definition, return and keywords
+pure integer elemental function fun5(arg) result(retval)
+    integer, intent(in) :: arg
+end function fun5
+