Merge pull request #53 from gnikit/feature/dataclasses

Feature/dataclasses

Author: gnikit

CHANGELOG.md

@@ -1,5 +1,14 @@
 # CHANGELONG
 
+## 2.2.4
+
+### Fixed
+
+- Fixed hovering value of literal and constant strings not displaying
+  ([#54](https://github.com/gnikit/fortls/issues/54))
+- Fixed hovering string length size is now matching the string
+  ([#55](https://github.com/gnikit/fortls/issues/55))
+
 ## 2.2.3
 
 ### Changed

fortls/constants.py

@@ -4,6 +4,8 @@
 import sys
 from dataclasses import dataclass, field
 
+from fortls.regex_patterns import FortranRegularExpressions
+
 PY3K = sys.version_info >= (3, 0)
 
 log = logging.getLogger(__name__)
@@ -63,6 +65,75 @@
 FORTRAN_LITERAL = "0^=__LITERAL_INTERNAL_DUMMY_VAR_"
 
 
+@dataclass
+class VAR_info:
+    type_word: str
+    keywords: list[str]
+    var_names: list[str]
+
+
+@dataclass
+class SUB_info:
+    name: str
+    args: str
+    mod_flag: bool
+    keywords: list[str]
+
+
+@dataclass
+class SELECT_info:
+    type: int
+    binding: str
+    desc: str
+
+
+@dataclass
+class CLASS_info:
+    name: str
+    parent: str
+    keywords: str
+
+
+@dataclass
+class USE_info:
+    mod_name: str
+    only_list: set[str]
+    rename_map: dict[str, str]
+
+
+@dataclass
+class GEN_info:
+    bound_name: str
+    pro_links: list[str]
+    vis_flag: int
+
+
+@dataclass
+class SMOD_info:
+    name: str
+    parent: str
+
+
+@dataclass
+class INT_info:
+    name: str
+    abstract: bool
+
+
+@dataclass
+class VIS_info:
+    type: int
+    obj_names: list[str]
+
+
+@dataclass
+class INCLUDE_info:
+    line_number: int
+    path: str
+    file: None  # fortran_file
+    scope_objs: list[str]
+
+
 @dataclass
 class RESULT_sig:
     name: str = field(default=None)
@@ -81,3 +152,7 @@ class FUN_sig:
     def __post_init__(self):
         if not self.result.name:
             self.result.name = self.name
+
+
+# Fortran Regular Expressions dataclass variable, immutable
+FRegex = FortranRegularExpressions()

fortls/helper_functions.py

@@ -3,19 +3,7 @@
 import os
 from pathlib import Path
 
-from fortls.constants import KEYWORD_ID_DICT, KEYWORD_LIST, log, sort_keywords
-from fortls.regex_patterns import (
-    DQ_STRING_REGEX,
-    FIXED_COMMENT_LINE_MATCH,
-    FREE_FORMAT_TEST,
-    LINE_LABEL_REGEX,
-    LOGICAL_REGEX,
-    NAT_VAR_REGEX,
-    NUMBER_REGEX,
-    OBJBREAK_REGEX,
-    SQ_STRING_REGEX,
-    WORD_REGEX,
-)
+from fortls.constants import KEYWORD_ID_DICT, KEYWORD_LIST, FRegex, log, sort_keywords
 
 
 def expand_name(line: str, char_poss: int) -> str:
@@ -35,7 +23,13 @@ def expand_name(line: str, char_poss: int) -> str:
     """
     # The order here is important.
     # WORD will capture substrings in logical and strings
-    regexs = [LOGICAL_REGEX, SQ_STRING_REGEX, DQ_STRING_REGEX, WORD_REGEX, NUMBER_REGEX]
+    regexs = [
+        FRegex.LOGICAL,
+        FRegex.SQ_STRING,
+        FRegex.DQ_STRING,
+        FRegex.WORD,
+        FRegex.NUMBER,
+    ]
     for r in regexs:
         for num_match in r.finditer(line):
             if num_match.start(0) <= char_poss <= num_match.end(0):
@@ -59,13 +53,13 @@ def detect_fixed_format(file_lines: list[str]) -> bool:
         True if file_lines are of Fixed Fortran style
     """
     for line in file_lines:
-        if FREE_FORMAT_TEST.match(line):
+        if FRegex.FREE_FORMAT_TEST.match(line):
             return False
-        tmp_match = NAT_VAR_REGEX.match(line)
+        tmp_match = FRegex.VAR.match(line)
         if tmp_match and tmp_match.start(1) < 6:
             return False
         # Trailing ampersand indicates free or intersection format
-        if not FIXED_COMMENT_LINE_MATCH.match(line):
+        if not FRegex.FIXED_COMMENT.match(line):
             line_end = line.split("!")[0].strip()
             if len(line_end) > 0 and line_end[-1] == "&":
                 return False
@@ -86,7 +80,7 @@ def strip_line_label(line: str) -> tuple[str, str | None]:
         Output string, Line label returns None if no line label present
     """
 
-    match = LINE_LABEL_REGEX.match(line)
+    match = FRegex.LINE_LABEL.match(line)
     if match is None:
         return line, None
     else:
@@ -118,11 +112,11 @@ def repl_dq(m):
         return '"{0}"'.format(" " * (len(m.group()) - 2))
 
     if maintain_len:
-        out_line = SQ_STRING_REGEX.sub(repl_sq, in_line)
-        out_line = DQ_STRING_REGEX.sub(repl_dq, out_line)
+        out_line = FRegex.SQ_STRING.sub(repl_sq, in_line)
+        out_line = FRegex.DQ_STRING.sub(repl_dq, out_line)
     else:
-        out_line = SQ_STRING_REGEX.sub("", in_line)
-        out_line = DQ_STRING_REGEX.sub("", out_line)
+        out_line = FRegex.SQ_STRING.sub("", in_line)
+        out_line = FRegex.DQ_STRING.sub("", out_line)
     return out_line
 
 
@@ -183,7 +177,7 @@ def find_word_in_line(line: str, word: str) -> tuple[int, int]:
         start and end positions (indices) of the word if not found it returns
         -1, len(word) -1"""
     i0 = -1
-    for poss_name in WORD_REGEX.finditer(line):
+    for poss_name in FRegex.WORD.finditer(line):
         if poss_name.group() == word:
             i0 = poss_name.start()
             break
@@ -417,7 +411,7 @@ def get_var_stack(line):
         final_var += line[section[0] : section[1]]
     #
     if final_var is not None:
-        final_op_split = OBJBREAK_REGEX.split(final_var)
+        final_op_split = FRegex.OBJBREAK.split(final_var)
         return final_op_split[-1].split("%")
     else:
         return None

fortls/langserver.py

@@ -21,6 +21,7 @@
     SELECT_TYPE_ID,
     SUBROUTINE_TYPE_ID,
     VAR_TYPE_ID,
+    FRegex,
     log,
 )
 from fortls.helper_functions import (
@@ -47,25 +48,12 @@
     get_use_tree,
 )
 from fortls.parse_fortran import fortran_file, get_line_context, process_file
-from fortls.regex_patterns import (
-    DQ_STRING_REGEX,
-    INT_STMNT_REGEX,
-    LOGICAL_REGEX,
-    NUMBER_REGEX,
-    SQ_STRING_REGEX,
-    src_file_exts,
-)
+from fortls.regex_patterns import src_file_exts
 from fortls.version import __version__
 
 # Global regexes
 # TODO: I think this can be replaced by fortls.regex_patterns type & class
 TYPE_DEF_REGEX = re.compile(r"[ ]*(TYPE|CLASS)[ ]*\([a-z0-9_ ]*$", re.I)
-# TODO: I think this can be replaced by fortls.regex_patterns
-SCOPE_DEF_REGEX = re.compile(r"[ ]*(MODULE|PROGRAM|SUBROUTINE|FUNCTION)[ ]+", re.I)
-# TODO: I think this can be replaced by fortls.regex_patterns END_REGEx
-END_REGEX = re.compile(
-    r"[ ]*(END)( |MODULE|PROGRAM|SUBROUTINE|FUNCTION|TYPE|DO|IF|SELECT)?", re.I
-)
 
 
 def init_file(filepath, pp_defs, pp_suffixes, include_dirs, sort):
@@ -540,6 +528,7 @@ def build_comp(
         if self.autocomplete_no_prefix:
             var_prefix = ""
         # Suggestions for user-defined type members
+        scope_list = []
         if is_member:
             curr_scope = file_obj.ast.get_inner_scope(ac_line + 1)
             type_scope = climb_type_tree(var_stack, curr_scope, self.obj_tree)
@@ -758,14 +747,16 @@ def get_definition(
             # Return a dummy object with the correct type & position in the doc
             if hover_req and curr_scope:
                 var_type = None
-                if NUMBER_REGEX.match(def_name):
+                if FRegex.NUMBER.match(def_name):
                     if any(s in def_name for s in [".", "e", "d"]):
                         var_type = f"{FORTRAN_LITERAL}REAL"
                     else:
                         var_type = f"{FORTRAN_LITERAL}INTEGER"
-                elif LOGICAL_REGEX.match(def_name):
+                elif FRegex.LOGICAL.match(def_name):
                     var_type = f"{FORTRAN_LITERAL}LOGICAL"
-                elif SQ_STRING_REGEX.match(def_name) or DQ_STRING_REGEX.match(def_name):
+                elif FRegex.SQ_STRING.match(def_name) or FRegex.DQ_STRING.match(
+                    def_name
+                ):
                     var_type = f"{FORTRAN_LITERAL}STRING"
                 if var_type:
                     return fortran_var(
@@ -817,7 +808,7 @@ def check_optional(arg, params):
         if line_prefix is None:
             return None
         # Test if scope declaration or end statement
-        if SCOPE_DEF_REGEX.match(curr_line) or END_REGEX.match(curr_line):
+        if FRegex.SCOPE_DEF.match(curr_line) or FRegex.END.match(curr_line):
             return None
         is_member = False
         try:
@@ -853,7 +844,7 @@ def check_optional(arg, params):
                         break
         # Check keywords
         if (var_obj is None) and (
-            INT_STMNT_REGEX.match(line_prefix[:sub_end]) is not None
+            FRegex.INT_STMNT.match(line_prefix[:sub_end]) is not None
         ):
             key = sub_name.lower()
             for candidate in get_intrinsic_keywords(self.statements, self.keywords, 0):
@@ -1064,7 +1055,7 @@ def create_signature_hover():
             elif var_obj.desc.endswith("LOGICAL"):
                 hover_array.append(create_hover("LOGICAL", True))
             elif var_obj.desc.endswith("STRING"):
-                hover_str = f"CHARACTER(LEN={len(var_obj.name)})"
+                hover_str = f"CHARACTER(LEN={len(var_obj.name)-2})"
                 hover_array.append(create_hover(hover_str, True))
 
             # Include the signature if one is present e.g. if in an argument list