refactor: edit incoming commits from stale PR

Author: gnikit

fortls/__init__.py

@@ -501,11 +501,7 @@ def locate_config(root: str) -> str | None:
         error_exit(f"Reading file failed: {err_str}")
     print(f"  Detected format: {'fixed' if file_obj.fixed else 'free'}")
     print("\n=========\nParser Output\n=========\n")
-    file_ast = file_obj.parse(
-        debug=True,
-        pp_defs=pp_defs,
-        include_dirs=include_dirs,
-    )
+    file_ast = file_obj.parse(debug=True, pp_defs=pp_defs, include_dirs=include_dirs)
     print("\n=========\nObject Tree\n=========\n")
     for obj in file_ast.get_scopes():
         print("{}: {}".format(obj.get_type(), obj.FQSN))

fortls/langserver.py

@@ -1323,9 +1323,7 @@ def serve_onChange(self, request: dict):
             # Update inheritance (currently file only)
             # tmp_file.ast.resolve_links(self.obj_tree, self.link_version)
         elif file_obj.preproc:
-            file_obj.preprocess(
-                pp_defs=self.pp_defs,
-            )
+            file_obj.preprocess(pp_defs=self.pp_defs)
             self.pp_defs = {**self.pp_defs, **file_obj.pp_defs}
 
     def serve_onOpen(self, request: dict):
@@ -1398,8 +1396,7 @@ def update_workspace_file(
                 if not file_changed:
                     return False, None
             ast_new = file_obj.parse(
-                pp_defs=self.pp_defs,
-                include_dirs=self.include_dirs,
+                pp_defs=self.pp_defs, include_dirs=self.include_dirs
             )
             # Add the included read in pp_defs from to the ones specified in the
             # configuration file
@@ -1463,10 +1460,7 @@ def file_init(
             # This is a bypass.
             # For more see on SO: shorturl.at/hwAG1
             set_keyword_ordering(sort)
-            file_ast = file_obj.parse(
-                pp_defs=pp_defs,
-                include_dirs=include_dirs,
-            )
+            file_ast = file_obj.parse(pp_defs=pp_defs, include_dirs=include_dirs)
         except:
             log.error("Error while parsing file %s", filepath, exc_info=True)
             return "Error during parsing"

fortls/parsers/internal/parser.py

@@ -1176,10 +1176,7 @@ def find_word_in_code_line(
         return line_no, word_range
 
     def preprocess(
-        self,
-        pp_defs: dict = None,
-        include_dirs: set = None,
-        debug: bool = False,
+        self, pp_defs: dict = None, include_dirs: set = None, debug: bool = False
     ) -> tuple[list, list]:
         if pp_defs is None:
             pp_defs = {}
@@ -1268,9 +1265,7 @@ def parse(
         if self.preproc:
             log.debug("=== PreProc Pass ===\n")
             pp_skips, pp_defines = self.preprocess(
-                pp_defs=pp_defs,
-                include_dirs=include_dirs,
-                debug=debug,
+                pp_defs=pp_defs, include_dirs=include_dirs, debug=debug
             )
             for pp_reg in pp_skips:
                 file_ast.start_ppif(pp_reg[0])
@@ -2043,7 +2038,6 @@ def replace_ops(expr: str):
             expr = expr.replace("!=", " <> ")
             expr = expr.replace("!", " not ")
             expr = expr.replace(" <> ", " != ")
-
             return expr
 
         def replace_defined(line: str):
@@ -2076,9 +2070,7 @@ def replace_vars(line: str):
 
         if defs is None:
             defs = {}
-
-        out_line = text
-        out_line = replace_defined(out_line)
+        out_line = replace_defined(text)
         out_line = replace_vars(out_line)
         try:
             line_res = eval(replace_ops(out_line))
@@ -2106,27 +2098,30 @@ def replace_vars(line: str):
         if def_cont_name is not None:
             output_file.append("")
             if line.rstrip()[-1] != "\\":
-                append_multiline_macro(defs_tmp, def_cont_name, line.strip())
+                defs_tmp[def_cont_name] = append_multiline_macro(
+                    defs_tmp[def_cont_name], line.strip()
+                )
                 def_cont_name = None
             else:
-                append_multiline_macro(defs_tmp, def_cont_name, line[0:-1].strip())
-
+                defs_tmp[def_cont_name] = append_multiline_macro(
+                    defs_tmp[def_cont_name], line[0:-1].strip()
+                )
             continue
         # Handle conditional statements
         match = FRegex.PP_REGEX.match(line)
-        if match and check_pp_prefix(match.group(1)):
+        if match:
             output_file.append(line)
             def_name = None
             if_start = False
             # Opening conditional statements
-            if match.group(2).lower() == "if ":
-                is_path = eval_pp_if(line[match.end(2) :], defs_tmp)
+            if match.group(1).lower() == "if ":
+                is_path = eval_pp_if(line[match.end(1) :], defs_tmp)
                 if_start = True
-            elif match.group(2).lower() == "ifdef":
+            elif match.group(1).lower() == "ifdef":
                 if_start = True
                 def_name = line[match.end(0) :].strip()
                 is_path = def_name in defs_tmp
-            elif match.group(2).lower() == "ifndef":
+            elif match.group(1).lower() == "ifndef":
                 if_start = True
                 def_name = line[match.end(0) :].strip()
                 is_path = not (def_name in defs_tmp)
@@ -2144,7 +2139,7 @@ def replace_vars(line: str):
             inc_start = False
             exc_start = False
             exc_continue = False
-            if match.group(2).lower() == "elif":
+            if match.group(1).lower() == "elif":
                 if (not pp_stack_group) or (pp_stack_group[-1][0] != len(pp_stack)):
                     # First elif statement for this elif group
                     if pp_stack[-1][0] < 0:
@@ -2156,15 +2151,15 @@ def replace_vars(line: str):
                     exc_continue = True
                     if pp_stack[-1][0] < 0:
                         pp_stack[-1][0] = i + 1
-                elif eval_pp_if(line[match.end(2) :], defs_tmp):
+                elif eval_pp_if(line[match.end(1) :], defs_tmp):
                     pp_stack[-1][1] = i + 1
                     pp_skips.append(pp_stack.pop())
                     pp_stack_group[-1][1] = True
                     pp_stack.append([-1, -1])
                     inc_start = True
                 else:
                     exc_start = True
-            elif match.group(2).lower() == "else":
+            elif match.group(1).lower() == "else":
                 if pp_stack[-1][0] < 0:
                     pp_stack[-1][0] = i + 1
                     exc_start = True
@@ -2180,7 +2175,7 @@ def replace_vars(line: str):
                     pp_skips.append(pp_stack.pop())
                     pp_stack.append([-1, -1])
                     inc_start = True
-            elif match.group(2).lower() == "endif":
+            elif match.group(1).lower() == "endif":
                 if pp_stack_group and (pp_stack_group[-1][0] == len(pp_stack)):
                     pp_stack_group.pop()
                 if pp_stack[-1][0] < 0:
@@ -2201,12 +2196,10 @@ def replace_vars(line: str):
             continue
         # Handle variable/macro definitions files
         match = FRegex.PP_DEF.match(line)
-        if (match is not None and check_pp_prefix(match.group(1))) and (
-            (len(pp_stack) == 0) or (pp_stack[-1][0] < 0)
-        ):
+        if (match is not None) and ((len(pp_stack) == 0) or (pp_stack[-1][0] < 0)):
             output_file.append(line)
             pp_defines.append(i + 1)
-            def_name = match.group(3)
+            def_name = match.group(2)
             # If this is an argument list of a function add them to the name
             # get_definition will only return the function name upon hover
             # hence if the argument list is appended in the def_name then
@@ -2215,11 +2208,8 @@ def replace_vars(line: str):
             # This also does not allow for multiline argument list definitions.
             # if match.group(3):
             #     def_name += match.group(3)
-            if (match.group(2) == "define") and (def_name not in defs_tmp):
+            if (match.group(1) == "define") and (def_name not in defs_tmp):
                 eq_ind = line[match.end(0) :].find(" ")
-                if eq_ind < 0:
-                    eq_ind = line[match.end(0) :].find("\t")
-
                 if eq_ind >= 0:
                     # Handle multiline macros
                     if line.rstrip()[-1] == "\\":
@@ -2231,11 +2221,11 @@ def replace_vars(line: str):
                     def_value = "True"
 
                 # are there arguments to parse?
-                if match.group(4):
-                    def_value = (match.group(5), def_value)
+                if match.group(3):
+                    def_value = (match.group(4), def_value)
 
                 defs_tmp[def_name] = def_value
-            elif (match.group(2) == "undef") and (def_name in defs_tmp):
+            elif (match.group(1) == "undef") and (def_name in defs_tmp):
                 defs_tmp.pop(def_name, None)
             log.debug(f"{line.strip()} !!! Define statement({i + 1})")
             continue
@@ -2286,10 +2276,9 @@ def replace_vars(line: str):
             def_regex = def_regexes.get(def_tmp)
             if def_regex is None:
                 if isinstance(value, tuple):
-                    def_regex = expand_def_func_macro(def_tmp, value)
+                    def_regex = expand_func_macro(def_tmp, value)
                 else:
                     def_regex = re.compile(rf"\b{def_tmp}\b")
-
                 def_regexes[def_tmp] = def_regex
 
             if isinstance(def_regex, tuple):
@@ -2305,7 +2294,7 @@ def replace_vars(line: str):
     return output_file, pp_skips, pp_defines, defs_tmp
 
 
-def expand_def_func_macro(def_name: str, def_value: tuple[str, str]):
+def expand_func_macro(def_name: str, def_value: tuple[str, str]):
     def_args, sub = def_value
     def_args = def_args.split(",")
     regex = re.compile(rf"\b{def_name}\s*\({','.join(['(.*)']*len(def_args))}\)")
@@ -2317,19 +2306,9 @@ def expand_def_func_macro(def_name: str, def_value: tuple[str, str]):
     return regex, sub
 
 
-def append_multiline_macro(pp_defs: dict, def_name: str, line: str):
-    def_value = pp_defs[def_name]
-    def_args = None
+def append_multiline_macro(def_value: str | tuple, line: str):
     if isinstance(def_value, tuple):
         def_args, def_value = def_value
-
-    def_value += line
-
-    if def_args is not None:
-        def_value = (def_args, def_value)
-
-    pp_defs[def_name] = def_value
-
-
-def check_pp_prefix(prefix: str):
-    return prefix == "#"
+        def_value += line
+        return (def_args, def_value)
+    return def_value + line

fortls/regex_patterns.py

@@ -124,17 +124,14 @@ class FortranRegularExpressions:
     FREE_FORMAT_TEST: Pattern = compile(r"[ ]{1,4}[a-z]", I)
     # Preprocessor matching rules
     DEFINED: Pattern = compile(r"defined[ ]*\(?[ ]*([a-z_]\w*)[ ]*\)?", I)
-    PP_REGEX: Pattern = compile(
-        r"[ ]*(#)[ ]*(if |ifdef|ifndef|else|elif|endif)",
-        I,
-    )
+    PP_REGEX: Pattern = compile(r"[ ]*#[ ]*(if |ifdef|ifndef|else|elif|endif)", I)
     PP_DEF: Pattern = compile(
-        r"[ ]*(#)[ ]*(define|undef|undefined)" r"[ ]+(\w+)(\([ ]*([ \w,]*?)[ ]*\))?",
+        r"[ ]*#[ ]*(define|undef|undefined)[ ]*(\w+)(\([ ]*([ \w,]*?)[ ]*\))?",
         I,
     )
     PP_DEF_TEST: Pattern = compile(r"(![ ]*)?defined[ ]*\([ ]*(\w*)[ ]*\)$", I)
-    PP_INCLUDE: Pattern = compile(r"[ ]*#[ ]*include[ ]+([\"\w\.]*)", I)
-    PP_ANY: Pattern = compile(r"(^[ ]*(?:#)[ ]*\w*:?\w+)")
+    PP_INCLUDE: Pattern = compile(r"[ ]*#[ ]*include[ ]*([\"\w\.]*)", I)
+    PP_ANY: Pattern = compile(r"^[ ]*#:?[ ]*(\w+)")
     # Context matching rules
     CALL: Pattern = compile(r"[ ]*CALL[ ]+[\w%]*$", I)
     INT_STMNT: Pattern = compile(r"^[ ]*[a-z]*$", I)

test/test_source/pp/.pp_conf.json

@@ -7,5 +7,5 @@
   "pp_suffixes": [".h", ".F90"],
   "incl_suffixes": [".h"],
   "include_dirs": ["include"],
-  "pp_defs": { "HAVE_CONTIGUOUS": "" },
+  "pp_defs": { "HAVE_CONTIGUOUS": "" }
 }