tree 62ab3670d2854e32967a65cf79477bcc31851af5
parent a48521671ee5836abdf1a62a7aaaf3547852aba6
author Bob Nystrom <robert@stuffwithstuff.com> 1519263529 -0800
committer GitHub <noreply@github.com> 1519263529 -0800
gpgsig -----BEGIN PGP SIGNATURE-----
 
 wsBcBAABCAAQBQJajh8pCRBK7hj4Ov3rIwAAdHIIAJzUwlxIgAkDuwfAU3+vudHN
 HvILJGcvVy5mI87gERF7iJQ4uJWJCwyBc+RyyxrULVc3dWjEqVzpBaJdnu2bwyrI
 3e67WeS8XcOgeE9QFdZwPUb3Y6VCDas0ijc8hC1Zu/qPsfocuBBc8fJAQ/wjb984
 kueFSmyIvTP0ca74NYJyu1OdkxT+x70MkwWfcpUUEBSOuLNgWZzccR1gWCJ8Rc5w
 ykdoChlrdSU5NT1w1T9Us5t4J8fFCHw/b2SqBR9bekeej1g9ZWoqWMB0pbijQ1Im
 oRwc49bsou2pTaJMAzPaJneYSlNgS2z6yG44iv7Td8kRr8+HlhZmX/79UiaH34s=
 =EudN
 -----END PGP SIGNATURE-----
 

Tweak how initialization lists are handled after trailing commas. (#673)

* Tweak how initialization lists are handled after trailing commas.

This gets avoids the pointless newlines of the old formatting rules,
but keeps it otherwise closer to the original behavior than
43832d24e7b86a165ec6a1765cbbb3644cae5f38 does.

In particular, initialization lists are always indented +6. This ensures
that initialization lists line up for constructors with trailing commas,
without, with optional parameters, mandatory, or none at all.

* Who formats the formatter?

* Revise comment.
