GNU logs - #31806, boring messages

Message sent to bug-cc-mode@HIDDEN:

Subject: bug#31806: CC Mode 5.33.1 (C/*l); compound literal indentation
Resent-From: Ken Raeburn <raeburn@HIDDEN>
Original-Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>
Resent-CC: bug-cc-mode@HIDDEN
Resent-Date: Tue, 12 Jun 2018 21:57:01 +0000
Resent-Message-ID: <handler.31806.B.15288405794940 <at> debbugs.gnu.org>
Resent-Sender: help-debbugs@HIDDEN
To: 31806 <at> debbugs.gnu.org
From: Ken Raeburn <raeburn@HIDDEN>
Date: Tue, 12 Jun 2018 17:56:08 -0400
Message-ID: <8736xrbrev.fsf@HIDDEN>
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: quoted-printable
Precedence: list
Errors-To: debbugs-submit-bounces <at> debbugs.gnu.org
Sender: "Debbugs-submit" <debbugs-submit-bounces <at> debbugs.gnu.org>


Indentation is inconsistent for field initializers in compound literals,
and it appears to be influenced by context:

    struct foo f3()
    {
      int x =3D 42;
      return (struct foo) {
        .a =3D 1,
          .b =3D 2,
          .c =3D 3,
          };
    }

The ".b" and ".c" lines are indented two positions further than the
".a" line.  They should be consistent.

Syntatic analysis:
Start of ".a" line is
  ((statement-block-intro 469))
Start of ".b" line and start of ".c" line are
  ((defun-block-intro 469) (statement-cont 469))
Emacs 25.3 analyzed and indented this one the same way.


Without the extra initial statement in the function, the indentation
comes out differently:

    struct foo f3()
    {
      return (struct foo) {
        .a =3D 1,
                             .b =3D 2,
                             .c =3D 3,
                             };
    }

The ".a" line is indented two positions from the start of "return".  The
other two are indented three positions relative to the "{", making their
position sensitive to the length of the type name.

While I could see an argument for changing the indentation to be
relative to the braces, I can also see an argument for the old way too,
and I think I liked the old way better.  (Bug #27402 may be related?)
If this was intentional, do we have a knob for picking between the two?
In any case, the indentation of the three lines should be consistent
here too.

Syntactic analysis:
Start of ".a" line is
  ((statement-block-into 220))
Start of ".b" line and start of ".c" line are
  ((brace-list-intro 220) (statement-cont 220))

Under Emacs 25.3, these had defun-block-intro instead of
brace-list-intro, and were indented two columns further than the ".a"
line, which was also wrong.

    void f3()
    {
      y =3D (struct foo) {
                        .a =3D 1,
                        .b =3D 2,
                        .c =3D 3,
      };
    }

The ".a" line is indented one column past the "{".

Syntactic analysis:
The ".a" line is
  ((brace-list-intro 563))
The ".b" and ".c" lines are
  ((brace-list-entry 602))

Emacs 25.3 indented all three lines two columns past the "y", and had a
similar syntactic analysis of the lines, so this is arguably a
regression.

    struct foo f3x()
    {
      return (struct foo) {
        1,
          2,
          3,
          };
    }

Here, without the designated initializer syntax, it's consistently two
columns further than "return" for the "1", and two columns further for
the following values.  Adding an extra variable declaration at the start
of the function doesn't change the result.

This should probably be consistent with the indentation for the
designated-initializer syntax.

Emacs 25.3 indented all of the initializer values two columns past the
"return", and lined the "}" up with the "return, so this is a
regression.




Emacs  : GNU Emacs 26.1 (build 1, x86_64-pc-linux-gnu, GTK+ Version 3.22.30)
 of 2018-05-31
Package: CC Mode 5.33.1 (C/*l)
Buffer Style: user
c-emacs-features: (pps-extended-state col-0-paren posix-char-classes gen-st=
ring-delim gen-comment-delim syntax-properties 1-bit)

current state:
=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D
(setq
 c-basic-offset 2
 c-comment-only-line-offset 0
 c-indent-comment-alist '((anchored-comment column . 0) (end-block space . =
1)
			  (cpp-end-block space . 2))
 c-indent-comments-syntactically-p nil
 c-block-comment-prefix "* "
 c-comment-prefix-regexp '((pike-mode . "//+!?\\|\\**") (awk-mode . "#+")
			   (other . "//+\\|\\**"))
 c-doc-comment-style '((java-mode . javadoc) (pike-mode . autodoc)
		       (c-mode . gtkdoc))
 c-cleanup-list '(scope-operator)
 c-hanging-braces-alist '((brace-list-open) (brace-entry-open)
			  (statement-cont) (substatement-open after)
			  (block-close . c-snug-do-while)
			  (extern-lang-open after) (namespace-open after)
			  (module-open after) (composition-open after)
			  (inexpr-class-open after)
			  (inexpr-class-close before) (arglist-cont-nonempty))
 c-hanging-colons-alist nil
 c-hanging-semi&comma-criteria '(c-semi&comma-inside-parenlist)
 c-backslash-column 48
 c-backslash-max-column 72
 c-special-indent-hook '(c-gnu-impose-minimum)
 c-label-minimum-indentation 1
 c-offsets-alist '((inexpr-class . +)
		   (inexpr-statement . +)
		   (lambda-intro-cont . +)
		   (inlambda . c-lineup-inexpr-block)
		   (template-args-cont c-lineup-template-args +)
		   (incomposition . +)
		   (inmodule . +)
		   (innamespace . +)
		   (inextern-lang . +)
		   (composition-close . 0)
		   (module-close . 0)
		   (namespace-close . 0)
		   (extern-lang-close . 0)
		   (composition-open . 0)
		   (module-open . 0)
		   (namespace-open . 0)
		   (extern-lang-open . 0)
		   (objc-method-call-cont
		    c-lineup-ObjC-method-call-colons
		    c-lineup-ObjC-method-call
		    +
		    )
		   (objc-method-args-cont . c-lineup-ObjC-method-args)
		   (objc-method-intro . [0])
		   (friend . 0)
		   (cpp-define-intro c-lineup-cpp-define +)
		   (cpp-macro-cont . +)
		   (cpp-macro . [0])
		   (inclass . +)
		   (stream-op . c-lineup-streamop)
		   (arglist-cont-nonempty
		    c-lineup-gcc-asm-reg
		    c-lineup-arglist
		    )
		   (arglist-cont c-lineup-gcc-asm-reg 0)
		   (comment-intro
		    c-lineup-knr-region-comment
		    c-lineup-comment
		    )
		   (catch-clause . 0)
		   (else-clause . 0)
		   (do-while-closure . 0)
		   (access-label . -)
		   (case-label . 0)
		   (substatement . +)
		   (statement-case-intro . +)
		   (statement . 0)
		   (brace-entry-open . 0)
		   (brace-list-entry . c-lineup-under-anchor)
		   (brace-list-close . 0)
		   (block-close . 0)
		   (block-open . 0)
		   (inher-cont . c-lineup-multi-inher)
		   (inher-intro . +)
		   (member-init-cont . c-lineup-multi-inher)
		   (member-init-intro . +)
		   (annotation-var-cont . +)
		   (annotation-top-cont . 0)
		   (topmost-intro . 0)
		   (knr-argdecl . 0)
		   (func-decl-cont . +)
		   (inline-close . 0)
		   (class-close . 0)
		   (class-open . 0)
		   (defun-block-intro . +)
		   (defun-close . 0)
		   (defun-open . 0)
		   (c . c-lineup-C-comments)
		   (string . c-lineup-dont-change)
		   (topmost-intro-cont . c-lineup-topmost-intro-cont)
		   (brace-list-intro . +)
		   (brace-list-open . 0)
		   (inline-open . +)
		   (arglist-close . +)
		   (arglist-intro . +)
		   (statement-cont . +)
		   (statement-case-open . 0)
		   (label . 2)
		   (substatement-label . 2)
		   (substatement-open . +)
		   (knr-argdecl-intro . +)
		   (statement-block-intro . +)
		   )
 c-buffer-is-cc-mode 'c-mode
 c-tab-always-indent t
 c-syntactic-indentation t
 c-syntactic-indentation-in-macros t
 c-ignore-auto-fill '(string cpp code)
 c-auto-align-backslashes t
 c-backspace-function 'backward-delete-char-untabify
 c-delete-function 'delete-char
 c-electric-pound-behavior '(alignleft)
 c-default-style '((java-mode . "java") (awk-mode . "awk") (other . "gnu"))
 c-enable-xemacs-performance-kludge-p nil
 c-old-style-variable-behavior nil
 defun-prompt-regexp nil
 tab-width 8
 comment-column 32
 parse-sexp-ignore-comments t
 parse-sexp-lookup-properties t
 auto-fill-function nil
 comment-multi-line t
 comment-start-skip "\\(//+\\|/\\*+\\)\\s *"
 fill-prefix nil
 fill-column 79
 paragraph-start "[ 	]*\\(//+\\|\\**\\)[ 	]*$\\|^\f"
 adaptive-fill-mode t
 adaptive-fill-regexp "[ 	]*\\(//+\\|\\**\\)[ 	]*\\([ 	]*\\([-=E2=80=93!|#%=
;>*=C2=B7=E2=80=A2=E2=80=A3=E2=81=83=E2=97=A6]+[ 	]*\\)*\\)"
 )

Message sent:

Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable
MIME-Version: 1.0
X-Mailer: MIME-tools 5.505 (Entity 5.505)
Content-Type: text/plain; charset=utf-8
X-Loop: help-debbugs@HIDDEN
From: help-debbugs@HIDDEN (GNU bug Tracking System)
To: Ken Raeburn <raeburn@HIDDEN>
Subject: bug#31806: Acknowledgement (CC Mode 5.33.1 (C/*l); compound
 literal indentation)
Message-ID: <handler.31806.B.15288405794940.ack <at> debbugs.gnu.org>
References: <8736xrbrev.fsf@HIDDEN>
X-Gnu-PR-Message: ack 31806
X-Gnu-PR-Package: cc-mode
Reply-To: 31806 <at> debbugs.gnu.org
Date: Tue, 12 Jun 2018 21:57:01 +0000

Thank you for filing a new bug report with debbugs.gnu.org.

This is an automatically generated reply to let you know your message
has been received.

Your message is being forwarded to the package maintainers and other
interested parties for their attention; they will reply in due course.

Your message has been sent to the package maintainer(s):
 bug-cc-mode@HIDDEN

If you wish to submit further information on this problem, please
send it to 31806 <at> debbugs.gnu.org.

Please do not send mail to help-debbugs@HIDDEN unless you wish
to report a problem with the Bug-tracking system.

--=20
31806: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=3D31806
GNU Bug Tracking System
Contact help-debbugs@HIDDEN with problems

Last modified: Mon, 25 Nov 2019 12:00:02 UTC

GNU bug tracking system
Copyright (C) 1999 Darren O. Benham, 1997 nCipher Corporation Ltd, 1994-97 Ian Jackson.