[nongnu] elpa/go-mode 6b67088 432/495: Support trailing commas as dangling operators.

[ELPA Syncer]

branch: elpa/go-mode
commit 6b67088ef7bc6204403109e76862d88c41c267c2
Author: Muir Manders <muir@retailnext.net>
Commit: Peter Sanford <psanford@sanford.io>

    Support trailing commas as dangling operators.
    
    Sometimes a trailing comma behaves like a dangling
    operator (i.e. indents following line). For example:
    
    // This comma is a dangling operator since it indents the "2".
    return 1,
      2
    
    // This comma isn't a dangling operator since it doesn't indent
    // the "2" (the "2" is indented due to the paren block, not the
    // dangling comma).
    foo(
      1,
      2,
    )
    
    // Similarly, not a dangling operator because the indent is due
    // to the curlies.
    Foo{
      A: 1,
      B: 2,
    }
    
    We now have special logic to sometimes treat a trailing comma as a
    dangling operator. Specifically, if we are inside parens, a composite
    literal or a struct definition, do not treat the comma as a dangling
    operator.
    
    Fixes #42
---
 go-mode.el                                         | 122 +++++++++++++++------
 .../indentation_tests/dangling_operator.go         |  10 +-
 .../testdata/indentation_tests/multiline_struct.go |  52 ++++++---
 3 files changed, 133 insertions(+), 51 deletions(-)

diff --git a/go-mode.el b/go-mode.el
index 5340b7c..6ccddde 100644
--- a/go-mode.el
+++ b/go-mode.el
@@ -58,14 +58,18 @@ function."
                         (progn (forward-visible-line arg) (point))))))
 
 (defun go-goto-opening-parenthesis (&optional _legacy-unused)
-  "Move up one level of parentheses."
+  "Move up one level of parentheses.
+
+Return non-nil if there was a paren to move up to."
   ;; The old implementation of go-goto-opening-parenthesis had an
   ;; optional argument to speed up the function.  It didn't change the
   ;; function's outcome.
 
   ;; Silently fail if there's no matching opening parenthesis.
   (condition-case nil
-      (backward-up-list)
+      (progn
+        (backward-up-list)
+        t)
     (scan-error nil)))
 
 
@@ -544,8 +548,11 @@ The returned value is the beginning of the line with the 
dangling operator."
       (save-excursion
         (beginning-of-line)
         (go--backward-irrelevant t)
-        (if (looking-back go-dangling-operators-regexp
-                          (- (point) go--max-dangling-operator-length))
+        (if (or
+             (looking-back go-dangling-operators-regexp
+                           (- (point) go--max-dangling-operator-length))
+             ;; treat comma as dangling operator in certain cases
+             (and (eq (char-before) ?,) (go--commas-indent-p)))
             (setq val (line-beginning-position))
           (setq val nil))
 
@@ -593,19 +600,9 @@ current line will be returned."
   "Return non-nil if current dangling line indents the following line."
   (save-excursion
     (let ((line-begin (line-beginning-position))
-          (start-paren-level (go-paren-level)))
-
-      (go-goto-opening-parenthesis)
-
-      (let ((in-parens (and
-                        ;; opening paren-like character is actually a paren
-                        (eq (char-after) ?\()
-                        ;; point is before the closing paren
-                        (< (go-paren-level) start-paren-level)
-                        ;;  still on starting line
-                        (>= (point) line-begin))))
+          (open-paren (go--open-paren-position)))
 
-        (if (not in-parens)
+          (if (not (and open-paren (>= open-paren line-begin)))
             ;; if line doesn't open a paren, check if we are a dangling line 
under
             ;; a dangling assignment with nothing on RHS of "="
             ;;
@@ -614,29 +611,86 @@ current line will be returned."
             ;;     baz ||
             ;;     qux
             (progn
-              (goto-char line-begin)
               (let ((prev-line (go-previous-line-has-dangling-op-p)))
-                (when prev-line
+                (goto-char line-begin)
+                (when (and
+                       prev-line
+                       (not (looking-at ".*,[[:space:]]*$"))) ;; doesn't apply 
to dangling commas
                   (goto-char prev-line)
                   (and
                    (not (go-previous-line-has-dangling-op-p))
                    (looking-at ".*=[[:space:]]*$")))))
-          (or
-           ;; previous line is dangling and opens indent
-           (let ((prev-line (go-previous-line-has-dangling-op-p)))
-             (when prev-line
-               (save-excursion
-                 (goto-char prev-line)
-                 (end-of-line)
-                 (go--dangling-line-opens-indent-p))))
-
-           ;; or paren is only preceded by identifier or other parens
-           (string-match-p "^[[:space:]]*[[:word:][:multibyte:]]*(*$" 
(buffer-substring line-begin (point)))
-
-           ;; or a preceding paren on this line opens an indent
-           (and
-            (> (point) line-begin)
-            (progn (backward-char) (go--dangling-line-opens-indent-p)))))))))
+
+            (goto-char open-paren)
+
+            (or
+             ;; previous line is dangling and opens indent
+             (let ((prev-line (go-previous-line-has-dangling-op-p)))
+               (when prev-line
+                 (save-excursion
+                   (goto-char prev-line)
+                   (end-of-line)
+                   (go--dangling-line-opens-indent-p))))
+
+             ;; or paren is only preceded by identifier or other parens
+             (string-match-p "^[[:space:]]*[[:word:][:multibyte:]]*(*$" 
(buffer-substring line-begin (point)))
+
+             ;; or a preceding paren on this line opens an indent
+             (and
+              (> (point) line-begin)
+              (progn (backward-char) (go--dangling-line-opens-indent-p))))))))
+
+(defun go--commas-indent-p ()
+  "Return non-nil if in a context where dangling commas indent next line."
+  (not (or
+        (go--open-paren-position)
+        (go--in-composite-literal-p)
+        (go--in-struct-definition-p))))
+
+(defun go--in-struct-definition-p ()
+  "Return non-nil if inside a struct definition."
+  (save-excursion
+    (and
+     ;; inside curlies
+     (go-goto-opening-parenthesis)
+     (eq (char-after) ?{)
+
+     ;; "struct" appears before opening curly
+     (backward-word)
+     (looking-at "struct[[:space:]]"))))
+
+(defun go--in-composite-literal-p ()
+  "Return non-nil if point is in a composite literal."
+  (save-excursion
+    (and
+     (go-goto-opening-parenthesis)
+
+     ;; opening paren-like character is curly
+     (eq (char-after) ?{)
+
+     (or
+      ;; preceded by non space (e.g. "Foo|{")
+      (not (looking-back "[[:space:]]" (1- (point))))
+
+      ;; or curly itself is in a composite literal (e.g. "Foo{|{")
+      (go--in-composite-literal-p)))))
+
+(defun go--open-paren-position ()
+  "Return non-nil if point is between '(' and ')'.
+
+The return value is the position of the opening paren."
+  (save-excursion
+    (let ((start-paren-level (go-paren-level)))
+      (and
+       (go-goto-opening-parenthesis)
+
+       ;; opening paren-like character is actually a paren
+       (eq (char-after) ?\()
+
+       ;; point is before the closing paren
+       (< (go-paren-level) start-paren-level)
+
+       (point)))))
 
 (defun go-indentation-at-point ()
   (save-excursion
diff --git a/test/testdata/indentation_tests/dangling_operator.go 
b/test/testdata/indentation_tests/dangling_operator.go
index 281ea53..78c0bb2 100644
--- a/test/testdata/indentation_tests/dangling_operator.go
+++ b/test/testdata/indentation_tests/dangling_operator.go
@@ -40,5 +40,13 @@ func init() {
                        true == false ||
                        false == false
 
-       return
+       a, b :=
+               1,
+               2
+
+       a,
+               b := 1, 2
+
+       return 123,
+               456
 }
diff --git a/test/testdata/indentation_tests/multiline_struct.go 
b/test/testdata/indentation_tests/multiline_struct.go
index 500dea6..26a5f6f 100644
--- a/test/testdata/indentation_tests/multiline_struct.go
+++ b/test/testdata/indentation_tests/multiline_struct.go
@@ -1,19 +1,39 @@
-testCase{char59 + "a." + char63 + "." + char63 + "." +
-       char63 + ".com",
-       false}
+func _() {
+       testCase{char59 + "a." + char63 + "." + char63 + "." +
+               char63 + ".com",
+               false}
 
-ifi := Interface{
-       Index:        int(index),
-       MTU:          int(row.Mtu),
-       Name:         name,
-       HardwareAddr: HardwareAddr(row.PhysAddr[:row.PhysAddrLen]),
-       Flags:        flags}
-ift = append(ift, ifi)
+       foo := Bar{
+               {
+                       Index: int(index),
+                       MTU:   int(row.Mtu),
+               },
+               {
+                       Index: int(index),
+                       MTU:   int(row.Mtu),
+               },
+       }
 
-{"230-Anonymous access granted, restrictions apply\n" +
-       "Read the file README.txt,\n" +
-       "230  please",
-       23,
-       230,
-       "Anonymous access granted, restrictions apply\nRead the file 
README.txt,\n please",
+       ifi := Interface{
+               Index:        int(index),
+               MTU:          int(row.Mtu),
+               Name:         name,
+               HardwareAddr: HardwareAddr(row.PhysAddr[:row.PhysAddrLen]),
+               Flags:        flags}
+       ift = append(ift, ifi)
+
+       Interface{
+               {"230-Anonymous access granted, restrictions apply\n" +
+                       "Read the file README.txt,\n" +
+                       "230  please",
+                       23,
+                       230,
+                       "Anonymous access granted, restrictions apply\nRead the 
file README.txt,\n please"},
+       }
+
+       var _ struct {
+               foo, // super
+               bar, // important
+               baz int //comments
+       }
 }