[nongnu] elpa/go-mode cf53daa 459/495: Fix indentation in naked blocks.

[ELPA Syncer]

branch: elpa/go-mode
commit cf53daac1f87771b469606840bfc06c20220e198
Author: Muir Manders <muir@mnd.rs>
Commit: Peter Sanford <psanford@sanford.io>

    Fix indentation in naked blocks.
    
    We were detecting naked blocks as composite literals:
    
    {
      // this isn't a composite literal!
    }
    
    The problematic counter example is:
    
    []Foo{
      {
        One: 1,
      },
      {  // this line looks like naked block in isolation
    
    Fix by invoking go--in-composite-literal-p recursively. If we are a
    composite literal with implicit type name, we will be contained in
    another composite literal.
    
    Closes: #310 [via git-merge-pr]
---
 go-mode.el                                         | 23 ++++++++++++----------
 .../indentation_tests/dangling_operator.go         |  5 +++++
 test/testdata/indentation_tests/labels.go          |  4 ++++
 3 files changed, 22 insertions(+), 10 deletions(-)

diff --git a/go-mode.el b/go-mode.el
index afc1e13..1020812 100644
--- a/go-mode.el
+++ b/go-mode.el
@@ -646,16 +646,19 @@ case keyword. It returns nil for the case line itself."
      (eq (char-after) ?{)
 
      (or
-      ;; Curly is preceded by non space (e.g. "Foo|{").
-      (not (looking-back "[[:space:]]" (1- (point))))
-
-      (and
-       (progn (skip-syntax-backward " ") t)
-
-       ;; Curly looks like a composite literal with implicit type
-       ;; name. In particular, the curly is the first character on the
-       ;; line or the previous character is a comma or colon.
-       (or (bolp) (looking-back "[,:]" (1- (point)))))))))
+      ;; Curly is preceded by non space (e.g. "Foo{"), definitely
+      ;; composite literal.
+      (zerop (skip-syntax-backward " "))
+
+      ;; Curly preceded by comma or semicolon. This is a composite
+      ;; literal with implicit type name.
+      (looking-back "[,:]" (1- (point)))
+
+      ;; If we made it to the beginning of line we are either a naked
+      ;; block or a composite literal with implict type name. If we
+      ;; are the latter, we must be contained in another composite
+      ;; literal.
+      (and (bolp) (go--in-composite-literal-p))))))
 
 (defun go--fill-prefix ()
   "Return fill prefix for following comment paragraph."
diff --git a/test/testdata/indentation_tests/dangling_operator.go 
b/test/testdata/indentation_tests/dangling_operator.go
index f8f77e0..a1749c7 100644
--- a/test/testdata/indentation_tests/dangling_operator.go
+++ b/test/testdata/indentation_tests/dangling_operator.go
@@ -78,6 +78,11 @@ func init() {
        a,
                b := 1, 2
 
+       {
+               a, b := 1,
+                       2
+       }
+
        1 + foo(
                3,
        )
diff --git a/test/testdata/indentation_tests/labels.go 
b/test/testdata/indentation_tests/labels.go
index 3b005bc..f5f6ac8 100644
--- a/test/testdata/indentation_tests/labels.go
+++ b/test/testdata/indentation_tests/labels.go
@@ -13,4 +13,8 @@ Label3: // Comments!
        Label4:
                // code
        }
+
+       {
+       Label5:
+       }
 }