feat: add support for start and end paren backspace in interface methods

Author: Jay-Madden

lua/auto-fix-return/fix.lua

@@ -208,7 +208,6 @@ function M.parse_return()
     return
   end
 
-
   -- Here we rebuild the entire return statement to a syntactically correct version
   -- splitting on commas to decide if there is a parameter list or a single value
   local fixed_def = M.build_fixed_definition(line, cursor_col)

lua/auto-fix-return/parsers/declaration.lua

@@ -103,6 +103,7 @@ function M.parse_declaration(cursor_row)
         ;; with the final error token for the , outside of the method_declaration
         (ERROR)? @outside_error_end
       )
+
       ;; For the following code
       ;; func (b *Bar) Foo() (string, int| {}
       ;; There is no 'result' node parsed, the error token contains the entire thing

lua/auto-fix-return/parsers/interface.lua

@@ -50,6 +50,46 @@ function M.parse_interface(cursor_row)
         .
         (ERROR)? @outside_error_end
       )
+
+      ;; Special parsing cases for the following code
+      ;; 
+      ;; type baz interface {
+      ;; 	Baz() i|,k)
+      ;; }
+      ;; ||
+      ;; type baz interface {
+      ;; 	Baz() (i,k
+      ;; }
+      ;; This is parsed as either the entire type return in the outside error or 
+      ;; the initial type identifier found in result
+      (
+        (method_elem
+          name: (_)
+          parameters: (_) 
+          result: (_)? @result
+        ) @func
+        .
+        (ERROR) @outside_error_end
+      )
+
+      ;; This is a special case for a multi method interface type with a missing end parentheses
+      ;; type Foo interface {
+      ;;   Bax() int
+      ;;   Baz() (i,k,l|
+      ;;   Bar() string
+      ;; }
+      (
+        (method_elem
+          name: (_)
+          parameters: (_) 
+          result: (parameter_list
+            (parameter_declaration
+              name: (identifier) @name
+            )
+            (ERROR)?
+          ) @result_start
+        ) @func
+      )
 	]
   ]]
   )
@@ -86,6 +126,10 @@ function M.parse_interface(cursor_row)
       if final_end_col == 0 then
         final_end_col = end_col
       end
+    elseif capture_name == "name" then
+      if end_col > final_end_col then
+        final_end_col = end_col
+      end
     elseif capture_name == "error_end" then
       final_end_col = end_col
     elseif capture_name == "outside_error_end" then
@@ -98,11 +142,14 @@ function M.parse_interface(cursor_row)
 
     ::continue::
 
-    -- The outside_error_above token stretches across multiple rows so
+    -- These capture edge cases stretch token stretches across multiple rows so
     -- we need to check it every time even if the continue check above fires
     if capture_name == "outside_error_above" then
       final_end_col = end_col
     end
+    if capture_name == "result_start" then
+      final_start_col = start_col
+    end
   end
 
   return {

lua/test/interface_test_spec.lua

@@ -813,4 +813,148 @@ describe("test interface method declarations", function()
       end)
     end
   )
+
+  describe(
+    "when a single function interface has multi return with only one starting parentheses",
+    function()
+      local winid = 0
+      before_each(function()
+        winid = utils.set_test_window_value({
+          "type Foo interface {",
+          "  Bar() (i,k|",
+          "}",
+        })
+        vim.cmd("AutoFixReturn")
+      end)
+
+      after_each(function()
+        utils.cleanup_test(winid)
+      end)
+
+      it("should add parentheses around the return type", function()
+        local lines = utils.get_win_lines(winid)
+        local expected = {
+          "type Foo interface {",
+          "  Bar() (i,k)",
+          "}",
+        }
+        eq(expected, lines)
+      end)
+
+      it("should set the cursor to inside the parens", function()
+        local char = utils.get_cursor_char(winid)
+        eq("k", char)
+      end)
+    end
+  )
+
+  describe(
+    "when a single function interface has multi return with only one ending parentheses",
+    function()
+      local winid = 0
+      before_each(function()
+        winid = utils.set_test_window_value({
+          "type Foo interface {",
+          "  Bar() i|,k)",
+          "}",
+        })
+        vim.cmd("AutoFixReturn")
+      end)
+
+      after_each(function()
+        utils.cleanup_test(winid)
+      end)
+
+      it("should add parentheses around the return type", function()
+        local lines = utils.get_win_lines(winid)
+        local expected = {
+          "type Foo interface {",
+          "  Bar() (i,k)",
+          "}",
+        }
+        eq(expected, lines)
+      end)
+
+      it("should set the cursor to inside the parens", function()
+        local char = utils.get_cursor_char(winid)
+        eq("(", char)
+      end)
+    end
+  )
+
+  describe(
+    "when a multiple function interface has multi return with only one starting parentheses",
+    function()
+      local winid = 0
+      before_each(function()
+        winid = utils.set_test_window_value({
+          "type Foo interface {",
+          "  Bax() int",
+          "  Bar() (i,k|",
+          "  Baz() string",
+          "}",
+        })
+        vim.cmd("AutoFixReturn")
+      end)
+
+      after_each(function()
+        utils.cleanup_test(winid)
+      end)
+
+      it("should add parentheses around the return type", function()
+        local lines = utils.get_win_lines(winid)
+        local expected = {
+          "type Foo interface {",
+          "  Bax() int",
+          "  Bar() (i,k)",
+          "  Baz() string",
+          "}",
+        }
+        eq(expected, lines)
+      end)
+
+      it("should set the cursor to inside the parens", function()
+        local char = utils.get_cursor_char(winid)
+        eq("k", char)
+      end)
+    end
+  )
+
+  describe(
+    "when a multiple function interface has multi return with only one ending parentheses",
+    function()
+      local winid = 0
+      before_each(function()
+        winid = utils.set_test_window_value({
+          "type Foo interface {",
+          "  Bax() int",
+          "  Bar() i|,k)",
+          "  Baz() string",
+          "}",
+        })
+        vim.cmd("AutoFixReturn")
+      end)
+
+      after_each(function()
+        utils.cleanup_test(winid)
+      end)
+
+      it("should add parentheses around the return type", function()
+        local lines = utils.get_win_lines(winid)
+        local expected = {
+          "type Foo interface {",
+          "  Bax() int",
+          "  Bar() (i,k)",
+          "  Baz() string",
+          "}",
+        }
+        eq(expected, lines)
+      end)
+
+      it("should set the cursor to inside the parens", function()
+        local char = utils.get_cursor_char(winid)
+        eq("(", char)
+      end)
+    end
+  )
 end)