Improves hover of functions

Functions now all display the same signature:
`type` `keywords` `function` `name(args)` `result(val)`

- Submodule module procedure functions now display like so
- functions without an explicit type or result now display like so
- Nested functions i.e. using functions as args displays like so

Closes Add support for Fortran scope/block snippets #47

Adds a series of hover unittests.
Also renamed the result variables

Author: gnikit

CHANGELOG.md

@@ -6,6 +6,8 @@
 
 - Fixed hovering over functions displaying as theire result types
   ([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))
 
 ## 2.2.1
 

fortls/intrinsics.py

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

fortls/objects.py

@@ -1087,8 +1087,8 @@ def __init__(
         args: str = "",
         mod_flag: bool = False,
         keywords: list = None,
-        return_type=None,
-        result_var=None,
+        result_type: list[str] = None,  # TODO: make this a string
+        result_name: str = None,
     ):
         super().__init__(file_ast, line_number, name, args, mod_flag, keywords)
         self.args: str = args.replace(" ", "").lower()
@@ -1097,65 +1097,69 @@ def __init__(
         self.in_children: list = []
         self.missing_args: list = []
         self.mod_scope: bool = mod_flag
-        self.result_var = result_var
-        self.result_obj = None
-        self.return_type = None
-        if return_type is not None:
-            self.return_type = return_type[0]
+        self.result_name: str = result_name
+        self.result_type: str = None
+        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
 
     def copy_interface(self, copy_source: fortran_function):
         # Call the parent class method
         child_names = super().copy_interface(copy_source)
         # Return specific options
-        self.result_var = copy_source.result_var
+        self.result_name = copy_source.result_name
+        self.result_type = copy_source.result_type
         self.result_obj = copy_source.result_obj
         if copy_source.result_obj is not None:
             if copy_source.result_obj.name.lower() not in child_names:
                 self.in_children.append(copy_source.result_obj)
 
     def resolve_link(self, obj_tree):
         self.resolve_arg_link(obj_tree)
-        if self.result_var is not None:
-            result_var_lower = self.result_var.lower()
-            for child in self.children:
-                if child.name.lower() == result_var_lower:
-                    self.result_obj = child
+        result_var_lower = self.result_name.lower()
+        for child in self.children:
+            if child.name.lower() == result_var_lower:
+                self.result_obj = child
+                # Update result value and type
+                self.result_name = child.name
+                self.result_type = child.get_desc()
 
     def get_type(self, no_link=False):
         return FUNCTION_TYPE_ID
 
     def get_desc(self):
-        if self.result_obj is not None:
-            return self.result_obj.get_desc() + " FUNCTION"
-        if self.return_type is not None:
-            return self.return_type + " FUNCTION"
+        if self.result_type:
+            return self.result_type + " FUNCTION"
         return "FUNCTION"
 
     def is_callable(self):
         return False
 
     def get_hover(self, long=False, include_doc=True, drop_arg=-1):
         fun_sig, _ = self.get_snippet(drop_arg=drop_arg)
-        fun_return = ""
-        if self.result_obj is not None:
-            fun_return, _ = self.result_obj.get_hover(include_doc=False)
-        if self.return_type is not None:
-            fun_return = self.return_type
-        keyword_list = get_keywords(self.keywords)
+        fun_sig += f" RESULT({self.result_name})"
+        keyword_list = []
+        if self.result_type:
+            keyword_list.append(self.result_type)
+        keyword_list += get_keywords(self.keywords)
         keyword_list.append("FUNCTION")
-        hover_array = [f"{fun_return} {' '.join(keyword_list)} {fun_sig}"]
+
+        hover_array = [f"{' '.join(keyword_list)} {fun_sig}"]
         self.get_docs_full(hover_array, long, include_doc, drop_arg)
         return "\n ".join(hover_array), long
 
     def get_interface(self, name_replace=None, change_arg=-1, change_strings=None):
         fun_sig, _ = self.get_snippet(name_replace=name_replace)
+        fun_sig += f" RESULT({self.result_name})"
         keyword_list = []
-        if self.return_type is not None:
-            keyword_list.append(self.return_type)
-        if self.result_obj is not None:
-            fun_sig += f" RESULT({self.result_obj.name})"
+        if self.result_type:
+            keyword_list.append(self.result_type)
         keyword_list += get_keywords(self.keywords)
         keyword_list.append("FUNCTION ")
+
         interface_array = self.get_interface_array(
             keyword_list, fun_sig, change_arg, change_strings
         )

fortls/parse_fortran.py

@@ -287,8 +287,23 @@ 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, return_type=None, mod_flag: bool = False):
-    """Attempt to read FUNCTION definition line"""
+def read_fun_def(line: str, result_type=None, mod_flag: bool = False):
+    """Attempt to read FUNCTION definition line
+
+    Parameters
+    ----------
+    line : str
+        file line
+    result_type : str, optional
+        type of function e.g. INTEGER, REAL, etc., by default None
+    mod_flag : bool, optional
+        flag for module and module procedure parsing, by default False
+
+    Returns
+    -------
+    tuple[Literal['fun'], FUN_info]
+        a named tuple
+    """
     mod_match = SUB_MOD_REGEX.match(line)
     mods_found = False
     keywords: list[str] = []
@@ -317,14 +332,14 @@ def read_fun_def(line: str, return_type=None, mod_flag: bool = False):
             word_match = [word for word in word_match]
             args = ",".join(word_match)
         trailing_line = trailing_line[paren_match.end(0) :]
-    #
-    return_var = None
-    if return_type is None:
-        trailing_line = trailing_line.strip()
-        results_match = RESULT_REGEX.match(trailing_line)
-        if results_match is not None:
-            return_var = results_match.group(1).strip().lower()
-    return "fun", FUN_info(name, args, return_type, return_var, mod_flag, keywords)
+
+    # 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)
 
 
 def read_sub_def(line: str, mod_flag: bool = False):
@@ -1772,16 +1787,21 @@ def parser_debug_msg(msg: str, line: str, ln: int):
                 args=obj_info.args,
                 mod_flag=obj_info.mod_flag,
                 keywords=keywords,
-                return_type=obj_info.return_type,
-                result_var=obj_info.return_var,
+                result_type=obj_info.return_type,
+                result_name=obj_info.return_var,
             )
             file_ast.add_scope(new_fun, END_FUN_REGEX)
-            if obj_info.return_type is not None:
+            # 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])
                 new_obj = fortran_var(
                     file_ast,
                     line_number,
-                    obj_info.name,
+                    result_name,
                     obj_info.return_type[0],
                     keywords,
                     keyword_info,

test/test_server.py

@@ -576,6 +576,12 @@ def check_return(result_array, checks):
     file_path = test_dir / "hover" / "functions.f90"
     string += hover_req(file_path, 1, 11)
     string += hover_req(file_path, 7, 19)
+    string += hover_req(file_path, 12, 12)
+    string += hover_req(file_path, 18, 19)
+    file_path = test_dir / "subdir" / "test_submod.F90"
+    string += hover_req(file_path, 29, 24)
+    file_path = test_dir / "test_diagnostic_int.f90"
+    string += hover_req(file_path, 19, 14)
 
     errcode, results = run_request(
         string, fortls_args=["--variable_hover", "--sort_keywords"]
@@ -594,10 +600,21 @@ def check_return(result_array, checks):
         "DOUBLE PRECISION, PARAMETER :: somevar = 23.12",
         "DOUBLE PRECISION, PARAMETER :: some = 1e-19",
         "INTEGER, POINTER",
-        """FUNCTION fun1(arg)
+        """INTEGER FUNCTION fun1(arg) RESULT(fun1)
+ INTEGER, INTENT(IN) :: arg""",
+        """INTEGER FUNCTION fun2(arg) RESULT(fun2)
+ INTEGER, INTENT(IN) :: arg""",
+        """INTEGER FUNCTION fun3(arg) RESULT(retval)
  INTEGER, INTENT(IN) :: arg""",
-        """INTEGER FUNCTION fun2(arg)
+        """INTEGER FUNCTION fun4(arg) RESULT(retval)
  INTEGER, INTENT(IN) :: arg""",
+        """REAL FUNCTION point_dist(a, b) RESULT(distance)
+ 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
+ REAL FUNCTION g(x) RESULT(z) :: g
+ REAL FUNCTION h(x) RESULT(z) :: h""",
     )
     assert len(ref_results) == len(results) - 1
     check_return(results[1:], ref_results)

test/test_source/hover/functions.f90

@@ -8,3 +8,14 @@ end function fun1
 integer function fun2(arg)
     integer, intent(in) :: arg
 end function fun2
+
+! function with return
+function fun3(arg) result(retval)
+    integer, intent(in) :: arg
+    integer :: retval
+end function fun3
+
+! function with type on definition and return
+integer function fun4(arg) result(retval)
+    integer, intent(in) :: arg
+end function fun4

test/test_source/subdir/test_submod.F90

@@ -27,8 +27,8 @@ end module points
 #define __PARENT_MOD__ points
 submodule (__PARENT_MOD__) points_a
 contains
-  module function point_dist
-    type(point) :: c
+  module function point_dist(a, b)
+    type(point), intent(in) :: a, b
     distance = sqrt((a%x - b%x)**2 + (a%y - b%y)**2)
   end function point_dist
 
@@ -40,5 +40,5 @@ end function point_dist
   module procedure is_point_equal_sub
     type(point) :: c
     test = is_point_equal(a,b)
-  end module procedure is_point_equal_sub
+  end procedure is_point_equal_sub
 end submodule points_a