Subject: Re: bug#56130: CC Mode 5.35.1 (C++//l); Indentation using braced initializer lists

From: Alan Mackenzie <[email-masked]>
Date: Fri, 24 Jun 2022 10:52:31 +0000

Hello, Michael.

On Tue, Jun 21, 2022 at 16:46:55 -0400, Michael Welsh Duggan wrote:
> Package: cc-mode

> This could possibly be considered a feature request.  It is relevant
> since C++ 11.  Consider the following code:

> #include <utility>
> 
> template <typename T>
> struct Foo {
>   Foo()
>     : a(1,
>         2)                      // This indents well
>   {}
> 
>   std::pair<int, int> a;
>   Foo(int)
>     : a{2,
>     3}                          // This indents poorly
>   {}
> };

> Braced initializer lists don't line up well, as opposed to parenthesis.

You can configure brace-list-intro in c-offsets-alist for this.  At the
moment, you've got

    (brace-list-intro . +)

, which is indenting the 3} one level in from Foo.  The entry

    (brace-list-intro . (first c-lineup-2nd-brace-entry-in-arglist
     c-lineup-class-decl-init-+ +))

has been the default in gnu style (and several others) for some while,
now.  The pertinent part of this is the function
c-lineup-class-decl-init-+, which would indent the 3} one level in from
the "a" in the line above.

Alternatively, you could use c-lineup-class-decl-after-brace, which
would line up the 3} under the 2 in the line above.  This give a neater
alignment when it is known there aren't too many long field names in the
initialisation list following the colon.

Both of these are described in the CC Mode manual page "List Line-Up".
I think one of them will give you what you need.  Would you please try
amending your style configuration, and confirm it fixes the problem, or
tell me how it falls short.  Thanks!

> Emacs  : GNU Emacs 29.0.50 (build 2, x86_64-pc-linux-gnu, X toolkit, cairo version 1.16.0)
>  of 2022-06-08
> Package: CC Mode 5.35.1 (C++//l)
> Buffer Style: Pharos
> c-emacs-features: (pps-extended-state col-0-paren posix-char-classes gen-string-delim gen-comment-delim syntax-properties 1-bit)

> current state:
> ==============
> (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 'doxygen
>  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 nil
>  c-label-minimum-indentation 1
>  c-offsets-alist '((inexpr-class . +)
>                    (inexpr-statement . +)
>                    (lambda-intro-cont . +)
>                    (inlambda . 0)
>                    (template-args-cont c-lineup-template-args +)
>                    (incomposition . +)
>                    (inmodule . +)
>                    (innamespace . 0)
>                    (inextern-lang . 0)
>                    (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 . *)
>                    (substatement . +)
>                    (statement-case-intro . *)
>                    (statement . 0)
>                    (brace-entry-open . 0)
>                    (brace-list-entry . 0)
>                    (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 . 0)
>                    (arglist-close . +)
>                    (arglist-intro . +)
>                    (statement-cont . c-lineup-math)
>                    (statement-case-open . *)
>                    (label . *)
>                    (substatement-label . 2)
>                    (substatement-open . 0)
>                    (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 nil
>  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 95
>  paragraph-start "[ 	]*\\(//+\\|\\**\\)[ 	]*$\\|^\f"
>  adaptive-fill-mode t
>  adaptive-fill-regexp "[ 	]*\\(//+\\|\\**\\)[ 	]*\\([ 	]*\\([-–!|#%;>*·•‣⁃◦]+[ 	]*\\)*\\)"
>  )
> -- 
> Michael Welsh Duggan
> ([email-masked])

-- 
Alan Mackenzie (Nuremberg, Germany).