Why does clang-format wrap this long line the way it does? - clang-format

Question

In clang-format the following template function declaration gets wrapped to three lines. I think it should only be wrapped to two. Is the problem in my .clang-format file or a bug in the tool?
template <class VEC3_T, class FLOAT_T>
FLOAT_T functionNamedBlahBlahhh(const VEC3_T blabla, const VEC3_T bla, FLOAT_T blah1,
FLOAT_T blah2) // foo
{
}
I am using clang-format version 10.0.0.
My .clang-format file is:
BasedOnStyle: LLVM # (LLVM, Google, Chromium, Mozilla, WebKit)
AccessModifierOffset: -4
AlignEscapedNewlines: Left
AllowShortBlocksOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: true
AllowShortFunctionsOnASingleLine: true
AllowShortIfStatementsOnASingleLine: true
AllowShortLoopsOnASingleLine: true
BreakBeforeBraces: Custom # If this is "Custom" then use the BraceWrapping settings
BraceWrapping:
AfterClass: false
AfterStruct: false
AfterUnion: true
AfterEnum: true
AfterNamespace: false
AfterControlStatement: false
AfterFunction: true
AfterExternBlock: false
BeforeCatch: true
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakConstructorInitializers: AfterColon
ColumnLimit: 130 # Drawback: AllowShort*OnASingleLine kind of goes crazy with it. Is there a Penalty property to adjust this?
IncludeBlocks: Regroup
IndentCaseLabels: false
IndentWidth: 4
KeepEmptyLinesAtTheStartOfBlocks: false
PointerAlignment: Left
SpaceBeforeCpp11BracedList: true
UseTab: Never
I see a few other cases where it wraps a long line to 3+ lines, as well. Here's one more:
OCLShaderEnv::OCLShaderEnv(OCLEnv* oclEnv, SVMStruct* svm, std::string prog, std::string kernelName, int width, int height,
std::string buildOptions, Camera* camera, void* otherStuff, std::array<float, 4> fillColor) :
m_device(oclEnv->getDevice()),
m_context(oclEnv->getContext()), m_cmdQ(oclEnv->getCmdQ()), m_prog(prog), m_kernelName(kernelName), m_width(width),
m_height(height), m_camera(camera), m_svmStructPtr(svm), m_oclEnv(oclEnv)
{
}
Note the three lines of initializers that could easily fit on two.

Answer 1

In your first example, there appears to be an interaction between 1) starting with just one of the parameters on a line, and 2) having a comment on that line. If you remove the comment, it formats to:
template <class VEC3_T, class FLOAT_T>
FLOAT_T functionNamedBlahBlahhh(const VEC3_T blabla, const VEC3_T bla, FLOAT_T blah1, FLOAT_T blah2)
{
}
as you would expect. If you leave the comment, but start with all parameters on one line, it leaves them all on one line, as you would expect.
It seems like a bug in clang-format to me. Possibly it is intended behavior, thinking that the comment must apply to just that parameter and so shouldn't be moved around? But it's hard to imagine that being very useful.
Workaround: Remove the comment, or manually put all parameter together on one line.
In your second example, this seems to be an interaction between 1) having a constructor with enough parameters that the parameters take multiple lines, 2) having multiple initializers for that constructor, and 3) setting BreakConstructorInitializers: AfterColon. In this case, the first initializer is put on its own line even if it could be combined with the subsequent initializers.
This also seems like a bug in clang-format to me.
Workaround: Reduce the parameters to the constructor so that they fit on one line - which I know you shouldn't have to do, but might make your code cleaner anyway. Or set BreakConstructorInitializers to something other than AfterColon. Or just live with the sub-optimal formatting, which is probably what I would do :(.