[clang-format][docs] mark new clang-format configuration options based on which version they would GA

[MyDeveloperDay]

Summary

Sometimes I see people unsure about which options they can use in specific versions of clang-format because https://clang.llvm.org/docs/ClangFormatStyleOptions.html points to the latest and greatest versions.

The reality is this says its version 13.0, but actually anything we add now, will not be in 13.0 GA but instead 14.0 GA (as 13.0 has already been branched (perhaps really the trunk should get relabelled as soon as the branch is made)

How about we introduce some nomenclature to the Format.h so that we can mark which options in the documentation were introduced for which version? If this seems appealing I'm happing to start going back over the older releases and marking the versions for each option.

[MyDeveloperDay]

This is just a very rough idea, feel free to pull it apart.

[krasimir]

I like this. Consider only displaying the major version (e.g., clang-format 14 instead of clang-format 14.0.0).

[MyDeveloperDay]

I agree this looks better

[HazardyKnusperkeks]

In D110432#3021391, @MyDeveloperDay wrote:

I agree this looks better

Full support for that. And for the whole change.

clang/docs/tools/dump_format_style.py

234

I think this was aligned to the opening parenthesis of match(.

If we only had an automatic formatting tool. 😃

clang/include/clang/Format/Format.h

1904

Could we move that into the comment block?

[MyDeveloperDay]

Mark all options with their version,
Move the \version into the comment
Warning if we add new options without a version

I think this is a fairly good representation (there could be a couple that are incorrectly labelled as a later version (if they have been modified), I had to kind of pull the "commit" from git blame then use the sha to determine the first branch. (with git name-rev <commit>), Its more likely to have said it was added in a later release, (especially if the type of the option had changed), but perhaps lets start here and if we see a few that are incorrectly labelled we can work our way back on those, but it was hard to do this for the 130+ options

[MyDeveloperDay]

clang/docs/tools/dump_format_style.py

234

I'm going to run this tool through pylint after this commit, as its currently very bad! but I don't want to do this in one go

************* Module dump_format_style
dump_format_style.py:20:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:21:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:24:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:25:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:26:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:29:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:30:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:31:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:34:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:36:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:37:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:38:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:39:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:40:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:41:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:42:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:43:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:44:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:47:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:48:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:49:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:50:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:51:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:52:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:53:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:54:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:55:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:56:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:57:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:61:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:62:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:63:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:64:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:65:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:66:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:67:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:68:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:70:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:71:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:72:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:74:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:77:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:78:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:79:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:80:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:83:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:84:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:85:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:86:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:87:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:90:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:91:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:92:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:93:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:94:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:95:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:96:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:98:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:99:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:100:0: C0301: Line too long (116/100) (line-too-long)
dump_format_style.py:100:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:102:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:103:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:105:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:106:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:107:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:108:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:110:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:113:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:114:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:115:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:116:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:118:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:119:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:122:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:123:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:124:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:126:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:127:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:132:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:133:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:134:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:135:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:137:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:138:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:141:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:142:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:143:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:144:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:145:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:147:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:148:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:150:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:151:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:152:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:152:0: W0301: Unnecessary semicolon (unnecessary-semicolon)
dump_format_style.py:155:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:156:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:157:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:158:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:160:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:161:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:167:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:168:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:169:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:170:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:171:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:172:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:173:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:174:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:175:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:177:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:178:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:179:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:181:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:182:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:183:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:185:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:186:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:187:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:188:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:191:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:192:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:194:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:196:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:197:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:198:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:199:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:200:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:201:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:202:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:204:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:205:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:206:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:207:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:208:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:209:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:210:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:211:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:212:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:213:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:214:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:215:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:216:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:217:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:218:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:219:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:220:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:221:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:222:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:223:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:224:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:225:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:226:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:227:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:228:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:229:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:230:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:231:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:232:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:233:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:236:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:237:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:238:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:239:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:240:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:241:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:242:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:243:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:244:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:245:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:246:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:247:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:248:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:249:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:250:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:251:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:252:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:253:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:254:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:255:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:256:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:257:0: C0301: Line too long (107/100) (line-too-long)
dump_format_style.py:257:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:258:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:259:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:261:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:262:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:263:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:264:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:265:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:266:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:267:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:268:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:271:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:272:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:273:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:274:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:275:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:276:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:277:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:278:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:279:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:279:0: C0325: Unnecessary parens after 'if' keyword (superfluous-parens)
dump_format_style.py:280:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:281:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:282:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:283:0: W0311: Bad indentation. Found 12 spaces, expected 20 (bad-indentation)
dump_format_style.py:283:0: W0301: Unnecessary semicolon (unnecessary-semicolon)
dump_format_style.py:284:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:285:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:286:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:288:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:289:0: W0311: Bad indentation. Found 4 spaces, expected 8 (bad-indentation)
dump_format_style.py:293:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:294:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:295:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:296:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:297:0: W0311: Bad indentation. Found 6 spaces, expected 12 (bad-indentation)
dump_format_style.py:298:0: W0311: Bad indentation. Found 8 spaces, expected 16 (bad-indentation)
dump_format_style.py:299:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:312:0: W0311: Bad indentation. Found 2 spaces, expected 4 (bad-indentation)
dump_format_style.py:1:0: C0114: Missing module docstring (missing-module-docstring)
dump_format_style.py:19:5: W1514: Using open without explicitly specifying an encoding (unspecified-encoding)
dump_format_style.py:23:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:23:26: W0621: Redefining name 'contents' from outer scope (line 307) (redefined-outer-name)
dump_format_style.py:24:16: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:25:12: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:28:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:37:36: W0621: Redefining name 'f' from outer scope (line 19) (redefined-outer-name)
dump_format_style.py:37:9: W1514: Using open without explicitly specifying an encoding (unspecified-encoding)
dump_format_style.py:37:36: C0103: Variable name "f" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:39:4: C0103: Variable name "cf" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:46:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:48:2: R1705: Unnecessary "elif" after "return" (no-else-return)
dump_format_style.py:60:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:61:2: R1705: Unnecessary "elif" after "return" (no-else-return)
dump_format_style.py:76:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:82:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:83:2: W0621: Redefining name 'indent' from outer scope (line 82) (redefined-outer-name)
dump_format_style.py:84:2: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:89:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:89:0: R0205: Class 'Option' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:90:27: W0622: Redefining built-in 'type' (redefined-builtin)
dump_format_style.py:100:6: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:100:10: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:103:6: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:103:10: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:106:6: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:106:18: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:108:6: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:108:18: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:89:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:112:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:112:0: R0205: Class 'NestedStruct' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:112:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:121:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:121:0: R0205: Class 'NestedField' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:127:11: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:121:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:131:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:131:0: R0205: Class 'Enum' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:131:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:140:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:140:0: R0205: Class 'NestedEnum' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:148:4: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:148:8: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:150:4: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:151:4: C0103: Variable name "s" doesn't conform to snake_case naming style (invalid-name)
dump_format_style.py:140:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:154:0: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:154:0: R0205: Class 'EnumValue' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:161:11: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:154:0: R0903: Too few public methods (1/2) (too-few-public-methods)
dump_format_style.py:166:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:169:4: W0621: Redefining name 'indent' from outer scope (line 82) (redefined-outer-name)
dump_format_style.py:175:11: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:190:0: C0116: Missing function or method docstring (missing-function-docstring)
dump_format_style.py:196:2: W0621: Redefining name 'options' from outer scope (line 301) (redefined-outer-name)
dump_format_style.py:190:0: R0914: Too many local variables (19/15) (too-many-locals)
dump_format_style.py:191:2: C0115: Missing class docstring (missing-class-docstring)
dump_format_style.py:191:2: R0205: Class 'State' inherits from object, can be safely removed from bases in python3 (useless-object-inheritance)
dump_format_style.py:191:2: R0903: Too few public methods (0/2) (too-few-public-methods)
dump_format_style.py:207:9: R1714: Consider merging these comparisons with "in" to "line in ('struct FormatStyle {', 'struct IncludeStyle {')" (consider-using-in)
dump_format_style.py:298:24: C0209: Formatting a regular string which could be a f-string (consider-using-f-string)
dump_format_style.py:190:0: R0912: Too many branches (38/12) (too-many-branches)
dump_format_style.py:190:0: R0915: Too many statements (94/50) (too-many-statements)
dump_format_style.py:301:23: R1732: Consider using 'with' for resource-allocating operations (consider-using-with)
dump_format_style.py:301:23: W1514: Using open without explicitly specifying an encoding (unspecified-encoding)
dump_format_style.py:302:24: R1732: Consider using 'with' for resource-allocating operations (consider-using-with)
dump_format_style.py:302:24: W1514: Using open without explicitly specifying an encoding (unspecified-encoding)
dump_format_style.py:305:0: C0103: Constant name "options_text" doesn't conform to UPPER_CASE naming style (invalid-name)
dump_format_style.py:307:11: R1732: Consider using 'with' for resource-allocating operations (consider-using-with)
dump_format_style.py:307:11: W1514: Using open without explicitly specifying an encoding (unspecified-encoding)

--------------------------------------------------------------------

Your code has been rated at -2.25/10 (previous run: -2.25/10, +0.00)

clang/include/clang/Format/Format.h

1904

yes let me do that its a better idea

3044

I think there is a bug here as ReflowComments is not in the bool operator==(const FormatStyle &R)

[HazardyKnusperkeks]

clang/docs/tools/dump_format_style.py

218

This needs to be escaped, doesn't it?

218

This shouldn't be needed, or?

clang/include/clang/Format/Format.h

766–767

The dot should be kept. Also somehow the output has the dot, but also an A afterwards.

2621

A Space is missing in that block.

3044

Some whitespace changes here.

And Version 14 is definitely wrong. It was already in 4 and not in 3.8, don't know how many version were in between.

3106

Was also already in 4, but just as bool.

[MyDeveloperDay]

• Minor available version corrections
• Addressing review comments

clang/docs/tools/dump_format_style.py

218

I don't think it means any character in a [...] but I'm not a regex expert

https://regex101.com/r/0e08JP/1

It is needed because prior to 4.0 we had 3.3->3.9

clang/include/clang/Format/Format.h

3044

clang/docs/ClangFormatStyleOptions.rst

+.. raw:: html
+
+      <style type="text/css">
+        .versionbadge { background-color: #1c913d; height: 20px; display: inline-block; width: 120px; text-align: center; border-radius: 5px; color: #FFFFFF; font-family="Verdana,Geneva,DejaVu Sans,sans-serif" }
+      </style>
+
+.. role:: versionbadge
+
 ==========================
 Clang-Format Style Options
 ==========================
 
 :doc:`ClangFormatStyleOptions` describes configurable formatting style options
 supported by :doc:`LibFormat` and :doc:`ClangFormat`.
 
 When using :program:`clang-format` command line utility or
* ``InheritParentConfig``
     to that.
 
     With this option you can overwrite some parts of your main style for your
     subdirectories. This is also possible through the command line, e.g.:
     ``--style={BasedOnStyle: InheritParentConfig, ColumnLimit: 20}``
 
 .. START_FORMAT_STYLE_OPTIONS
 
-**AccessModifierOffset** (``Integer``)
+**AccessModifierOffset** (``Integer``) :versionbadge:`clang-format 3.3`
   The extra indent or outdent of access modifiers, e.g. ``public:``.
 
-**AlignAfterOpenBracket** (``BracketAlignmentStyle``)
+**AlignAfterOpenBracket** (``BracketAlignmentStyle``) :versionbadge:`clang-format 3.8`
   If ``true``, horizontally aligns arguments after an open bracket.
 
   This applies to round brackets (parentheses), angle brackets and square
   brackets.
 
   Possible values:
 
   * ``BAS_Align`` (in configuration: ``Align``)
* ``BAS_AlwaysBreak`` (in configuration: ``AlwaysBreak``)
 
     .. code-block:: c++
 
       someLongFunction(
           argument1, argument2);
 
 
 
-**AlignArrayOfStructures** (``ArrayInitializerAlignmentStyle``)
+**AlignArrayOfStructures** (``ArrayInitializerAlignmentStyle``) :versionbadge:`clang-format 13`
   if not ``None``, when using initialization for an array of structs
   aligns the fields into columns.
 
   Possible values:
 
   * ``AIAS_Left`` (in configuration: ``Left``)
     Align array column and left justify the columns e.g.:
 
.. code-block:: c++
           { 7,     5,    "!!"}
       };
 
   * ``AIAS_None`` (in configuration: ``None``)
     Don't align array initializer columns.
 
 
 
-**AlignConsecutiveAssignments** (``AlignConsecutiveStyle``)
+**AlignConsecutiveAssignments** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
   Style of aligning consecutive assignments.
 
   ``Consecutive`` will result in formattings like:
 
   .. code-block:: c++
 
     int a            = 1;
     int somelongname = 2;
.. code-block:: c++
        int a            = 1;
        int somelongname = 2;
        double c         = 3;
 
        int d            = 3;
        /* A comment. */
        double e         = 4;
 
-**AlignConsecutiveBitFields** (``AlignConsecutiveStyle``)
+**AlignConsecutiveBitFields** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
   Style of aligning consecutive bit field.
 
   ``Consecutive`` will align the bitfield separators of consecutive lines.
   This will result in formattings like:
 
   .. code-block:: c++
 
     int aaaa : 1;
.. code-block:: c++
        int aaaa : 1;
        int b    : 12;
        int ccc  : 8;
 
        int d    : 2;
        /* A comment. */
        int ee   : 3;
 
-**AlignConsecutiveDeclarations** (``AlignConsecutiveStyle``)
+**AlignConsecutiveDeclarations** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
   Style of aligning consecutive declarations.
 
   ``Consecutive`` will align the declaration names of consecutive lines.
   This will result in formattings like:
 
   .. code-block:: c++
 
     int         aaaa = 12;
.. code-block:: c++
        int         aaaa = 12;
        float       b = 23;
        std::string ccc;
 
        int         a = 42;
        /* A comment. */
        bool        c = false;
 
-**AlignConsecutiveMacros** (``AlignConsecutiveStyle``)
+**AlignConsecutiveMacros** (``AlignConsecutiveStyle``) :versionbadge:`clang-format 13`
   Style of aligning consecutive macro definitions.
 
   ``Consecutive`` will result in formattings like:
 
   .. code-block:: c++
 
     #define SHORT_NAME       42
     #define LONGER_NAME      0x007f
.. code-block:: c++
        #define SHORT_NAME       42
        #define LONGER_NAME      0x007f
        #define EVEN_LONGER_NAME (2)
 
        #define foo(x)           (x * x)
        /* some comment */
        #define bar(y, z)        (y + z)
 
-**AlignEscapedNewlines** (``EscapedNewlineAlignmentStyle``)
+**AlignEscapedNewlines** (``EscapedNewlineAlignmentStyle``) :versionbadge:`clang-format 5`
   Options for aligning backslashes in escaped newlines.
 
   Possible values:
 
   * ``ENAS_DontAlign`` (in configuration: ``DontAlign``)
     Don't align escaped newlines.
 
     .. code-block:: c++
.. code-block:: c++
 
       #define A                                                                      \
         int aaaa;                                                                    \
         int b;                                                                       \
         int dddddddddd;
 
 
 
-**AlignOperands** (``OperandAlignmentStyle``)
+**AlignOperands** (``OperandAlignmentStyle``) :versionbadge:`clang-format 12`
   If ``true``, horizontally align operands of binary and ternary
   expressions.
 
   Possible values:
 
   * ``OAS_DontAlign`` (in configuration: ``DontAlign``)
     Do not align operands of binary and ternary expressions.
     The wrapped lines are indented ``ContinuationIndentWidth`` spaces from
* ``OAS_AlignAfterOperator`` (in configuration: ``AlignAfterOperator``)
 
     .. code-block:: c++
 
       int aaa = bbbbbbbbbbbbbbb
               + ccccccccccccccc;
 
 
 
-**AlignTrailingComments** (``Boolean``)
+**AlignTrailingComments** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, aligns trailing comments.
 
   .. code-block:: c++
 
     true:                                   false:
     int a;     // My comment a      vs.     int a; // My comment a
     int b = 2; // comment  b                int b = 2; // comment about b
 
-**AllowAllArgumentsOnNextLine** (``Boolean``)
+**AllowAllArgumentsOnNextLine** (``Boolean``) :versionbadge:`clang-format 9`
   If a function call or braced initializer list doesn't fit on a
   line, allow putting all arguments onto the next line, even if
   ``BinPackArguments`` is ``false``.
 
   .. code-block:: c++
 
     true:
     callFunction(
         a, b, c, d);
 
     false:
     callFunction(a,
                  b,
                  c,
                  d);
 
-**AllowAllConstructorInitializersOnNextLine** (``Boolean``)
+**AllowAllConstructorInitializersOnNextLine** (``Boolean``) :versionbadge:`clang-format 9`
   This option is **deprecated**. See ``NextLine`` of
   ``PackConstructorInitializers``.
 
-**AllowAllParametersOfDeclarationOnNextLine** (``Boolean``)
+**AllowAllParametersOfDeclarationOnNextLine** (``Boolean``) :versionbadge:`clang-format 3.3`
   If the function declaration doesn't fit on a line,
   allow putting all parameters of a function declaration onto
   the next line even if ``BinPackParameters`` is ``false``.
 
   .. code-block:: c++
 
     true:
     void myFunction(
         int a, int b, int c, int d, int e);
 
     false:
     void myFunction(int a,
                     int b,
                     int c,
                     int d,
                     int e);
 
-**AllowShortBlocksOnASingleLine** (``ShortBlockStyle``)
+**AllowShortBlocksOnASingleLine** (``ShortBlockStyle``) :versionbadge:`clang-format 11`
   Dependent on the value, ``while (true) { continue; }`` can be put on a
   single line.
 
   Possible values:
 
   * ``SBS_Never`` (in configuration: ``Never``)
     Never merge blocks into a single line.
 
* ``SBS_Always`` (in configuration: ``Always``)
 
     .. code-block:: c++
 
       while (true) {}
       while (true) { continue; }
 
 
 
-**AllowShortCaseLabelsOnASingleLine** (``Boolean``)
+**AllowShortCaseLabelsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 3.6`
   If ``true``, short case labels will be contracted to a single line.
 
   .. code-block:: c++
 
     true:                                   false:
     switch (a) {                    vs.     switch (a) {
     case 1: x = 1; break;                   case 1:
     case 2: return;                           x = 1;
     }                                         break;
                                             case 2:
                                               return;
                                             }
 
-**AllowShortEnumsOnASingleLine** (``Boolean``)
+**AllowShortEnumsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 12`
   Allow short enums on a single line.
 
   .. code-block:: c++
 
     true:
     enum { A, B } myEnum;
 
     false:
     enum {
       A,
       B
     } myEnum;
 
-**AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``)
+**AllowShortFunctionsOnASingleLine** (``ShortFunctionStyle``) :versionbadge:`clang-format 3.5`
   Dependent on the value, ``int f() { return 0; }`` can be put on a
   single line.
 
   Possible values:
 
   * ``SFS_None`` (in configuration: ``None``)
     Never merge functions into a single line.
 
.. code-block:: c++
 
       class Foo {
         void f() { foo(); }
       };
       void f() { bar(); }
 
 
 
-**AllowShortIfStatementsOnASingleLine** (``ShortIfStyle``)
+**AllowShortIfStatementsOnASingleLine** (``ShortIfStyle``) :versionbadge:`clang-format 9`
   Dependent on the value, ``if (a) return;`` can be put on a single line.
 
   Possible values:
 
   * ``SIS_Never`` (in configuration: ``Never``)
     Never put short ifs on the same line.
 
     .. code-block:: c++
.. code-block:: c++
 
       if (c) return;
       else {
         return;
       }
 
 
 
-**AllowShortLambdasOnASingleLine** (``ShortLambdaStyle``)
+**AllowShortLambdasOnASingleLine** (``ShortLambdaStyle``) :versionbadge:`clang-format 9`
   Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
   single line.
 
   Possible values:
 
   * ``SLS_None`` (in configuration: ``None``)
     Never merge lambdas into a single line.
 
* ``SLS_All`` (in configuration: ``All``)
 
     .. code-block:: c++
 
       auto lambda = [](int a) {}
       auto lambda2 = [](int a) { return a; };
 
 
 
-**AllowShortLoopsOnASingleLine** (``Boolean``)
+**AllowShortLoopsOnASingleLine** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, ``while (true) continue;`` can be put on a single
   line.
 
-**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``)
+**AlwaysBreakAfterDefinitionReturnType** (``DefinitionReturnTypeBreakingStyle``) :versionbadge:`clang-format 3.7`
   The function definition return type breaking style to use.  This
   option is **deprecated** and is retained for backwards compatibility.
 
   Possible values:
 
   * ``DRTBS_None`` (in configuration: ``None``)
     Break after return type automatically.
     ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
 
   * ``DRTBS_All`` (in configuration: ``All``)
     Always break after the return type.
 
   * ``DRTBS_TopLevel`` (in configuration: ``TopLevel``)
     Always break after the return types of top-level functions.
 
 
 
-**AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``)
+**AlwaysBreakAfterReturnType** (``ReturnTypeBreakingStyle``) :versionbadge:`clang-format 3.8`
   The function declaration return type breaking style to use.
 
   Possible values:
 
   * ``RTBS_None`` (in configuration: ``None``)
     Break after return type automatically.
     ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
 
.. code-block:: c++
       int f();
       int
       f() {
         return 1;
       }
 
 
 
-**AlwaysBreakBeforeMultilineStrings** (``Boolean``)
+**AlwaysBreakBeforeMultilineStrings** (``Boolean``) :versionbadge:`clang-format 3.4`
   If ``true``, always break before multiline string literals.
 
   This flag is mean to make cases where there are multiple multiline strings
   in a file look more consistent. Thus, it will only take effect if wrapping
   the string at that point leads to it being indented
   ``ContinuationIndentWidth`` spaces from the start of the line.
 
   .. code-block:: c++
 
      true:                                  false:
      aaaa =                         vs.     aaaa = "bbbb"
          "bbbb"                                    "cccc";
          "cccc";
 
-**AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``)
+**AlwaysBreakTemplateDeclarations** (``BreakTemplateDeclarationsStyle``) :versionbadge:`clang-format 7`
   The template declaration breaking style to use.
 
   Possible values:
 
   * ``BTDS_No`` (in configuration: ``No``)
     Do not force break before declaration.
     ``PenaltyBreakTemplateDeclaration`` is taken into account.
 
.. code-block:: c++
        }
        template <typename T>
        T foo(int aaaaaaaaaaaaaaaaaaaaa,
              int bbbbbbbbbbbbbbbbbbbbb) {
        }
 
 
 
-**AttributeMacros** (``List of Strings``)
+**AttributeMacros** (``List of Strings``) :versionbadge:`clang-format 13`
   A vector of strings that should be interpreted as attributes/qualifiers
   instead of identifiers. This can be useful for language extensions or
   static analyzer annotations.
 
   For example:
 
   .. code-block:: c++
 
     x = (char *__capability)&y;
     int function(void) __ununsed;
     void only_writes_to_buffer(char *__output buffer);
 
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     AttributeMacros: ['__capability', '__output', '__ununsed']
 
-**BinPackArguments** (``Boolean``)
+**BinPackArguments** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``false``, a function call's arguments will either be all on the
   same line or will have one line each.
 
   .. code-block:: c++
 
     true:
     void f() {
       f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
     }
 
     false:
     void f() {
       f(aaaaaaaaaaaaaaaaaaaa,
         aaaaaaaaaaaaaaaaaaaa,
         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
     }
 
-**BinPackParameters** (``Boolean``)
+**BinPackParameters** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``false``, a function declaration's or function definition's
   parameters will either all be on the same line or will have one line each.
 
   .. code-block:: c++
 
     true:
     void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
 
     false:
     void f(int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaa,
            int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
 
-**BitFieldColonSpacing** (``BitFieldColonSpacingStyle``)
+**BitFieldColonSpacing** (``BitFieldColonSpacingStyle``) :versionbadge:`clang-format 13`
   The BitFieldColonSpacingStyle to use for bitfields.
 
   Possible values:
 
   * ``BFCS_Both`` (in configuration: ``Both``)
     Add one space on each side of the ``:``
 
     .. code-block:: c++
* ``BFCS_After`` (in configuration: ``After``)
     needed for ``AlignConsecutiveBitFields``).
 
     .. code-block:: c++
 
       unsigned bf: 2;
 
 
 
-**BraceWrapping** (``BraceWrappingFlags``)
+**BraceWrapping** (``BraceWrappingFlags``) :versionbadge:`clang-format 3.8`
   Control of individual brace wrapping cases.
 
   If ``BreakBeforeBraces`` is set to ``BS_Custom``, use this to specify how
   each individual brace case should be handled. Otherwise, this is ignored.
 
   .. code-block:: yaml
 
     # Example of usage:
* ``bool SplitEmptyNamespace`` If ``false``, empty namespace body can be put on a single line.
 
     .. code-block:: c++
 
       namespace Foo   vs.  namespace Foo
       {}                   {
                            }
 
 
-**BreakAfterJavaFieldAnnotations** (``Boolean``)
+**BreakAfterJavaFieldAnnotations** (``Boolean``) :versionbadge:`clang-format 3.8`
   Break after each annotation on a field in Java files.
 
   .. code-block:: java
 
      true:                                  false:
      @Partial                       vs.     @Partial @Mock DataLoad loader;
      @Mock
      DataLoad loader;
 
-**BreakBeforeBinaryOperators** (``BinaryOperatorStyle``)
+**BreakBeforeBinaryOperators** (``BinaryOperatorStyle``) :versionbadge:`clang-format 3.6`
   The way to wrap binary operators.
 
   Possible values:
 
   * ``BOS_None`` (in configuration: ``None``)
     Break after operators.
 
     .. code-block:: c++
.. code-block:: c++
        bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                             + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                         == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                     && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
                            > ccccccccccccccccccccccccccccccccccccccccc;
 
 
 
-**BreakBeforeBraces** (``BraceBreakingStyle``)
+**BreakBeforeBraces** (``BraceBreakingStyle``) :versionbadge:`clang-format 3.7`
   The brace breaking style to use.
 
   Possible values:
 
   * ``BS_Attach`` (in configuration: ``Attach``)
     Always attach braces to surrounding context.
 
     .. code-block:: c++
.. code-block:: c++
       void bar() { foo(true); }
       } // namespace N
 
   * ``BS_Custom`` (in configuration: ``Custom``)
     Configure each individual brace in `BraceWrapping`.
 
 
 
-**BreakBeforeConceptDeclarations** (``Boolean``)
+**BreakBeforeConceptDeclarations** (``Boolean``) :versionbadge:`clang-format 13`
   If ``true``, concept will be placed on a new line.
 
   .. code-block:: c++
 
     true:
      template<typename T>
      concept ...
 
     false:
      template<typename T> concept ...
 
-**BreakBeforeTernaryOperators** (``Boolean``)
+**BreakBeforeTernaryOperators** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, ternary operators will be placed after line breaks.
 
   .. code-block:: c++
 
      true:
      veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
          ? firstValue
          : SecondValueVeryVeryVeryVeryLong;
 
      false:
      veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
          firstValue :
          SecondValueVeryVeryVeryVeryLong;
 
-**BreakConstructorInitializers** (``BreakConstructorInitializersStyle``)
+**BreakConstructorInitializers** (``BreakConstructorInitializersStyle``) :versionbadge:`clang-format 5`
   The break constructor initializers style to use.
 
   Possible values:
 
   * ``BCIS_BeforeColon`` (in configuration: ``BeforeColon``)
     Break constructor initializers before the colon and after the commas.
 
     .. code-block:: c++
* ``BCIS_AfterColon`` (in configuration: ``AfterColon``)
     .. code-block:: c++
 
        Constructor() :
            initializer1(),
            initializer2()
 
 
 
-**BreakInheritanceList** (``BreakInheritanceListStyle``)
+**BreakInheritanceList** (``BreakInheritanceListStyle``) :versionbadge:`clang-format 7`
   The inheritance list style to use.
 
   Possible values:
 
   * ``BILS_BeforeColon`` (in configuration: ``BeforeColon``)
     Break inheritance list before the colon and after the commas.
 
     .. code-block:: c++
* ``BILS_AfterComma`` (in configuration: ``AfterComma``)
     .. code-block:: c++
 
        class Foo : Base1,
                    Base2
        {};
 
 
 
-**BreakStringLiterals** (``Boolean``)
+**BreakStringLiterals** (``Boolean``) :versionbadge:`clang-format 3.9`
   Allow breaking string literals when formatting.
 
   .. code-block:: c++
 
      true:
      const char* x = "veryVeryVeryVeryVeryVe"
                      "ryVeryVeryVeryVeryVery"
                      "VeryLongString";
 
      false:
      const char* x =
        "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
 
-**ColumnLimit** (``Unsigned``)
+**ColumnLimit** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The column limit.
 
   A column limit of ``0`` means that there is no column limit. In this case,
   clang-format will respect the input's line breaking decisions within
   statements unless they contradict other rules.
 
-**CommentPragmas** (``String``)
+**CommentPragmas** (``String``) :versionbadge:`clang-format 3.7`
   A regular expression that describes comments with special meaning,
   which should not be split into lines or otherwise changed.
 
   .. code-block:: c++
 
      // CommentPragmas: '^ FOOBAR pragma:'
      // Will leave the following line unaffected
      #include <vector> // FOOBAR pragma: keep
 
-**CompactNamespaces** (``Boolean``)
+**CompactNamespaces** (``Boolean``) :versionbadge:`clang-format 5`
   If ``true``, consecutive namespace declarations will be on the same
   line. If ``false``, each namespace is declared on a new line.
 
   .. code-block:: c++
 
     true:
     namespace Foo { namespace Bar {
     }}
 
     false:
     namespace Foo {
     namespace Bar {
     }
     }
 
   If it does not fit on a single line, the overflowing namespaces get
   wrapped:
 
   .. code-block:: c++
 
     namespace Foo { namespace Bar {
     namespace Extra {
     }}}
 
-**ConstructorInitializerAllOnOneLineOrOnePerLine** (``Boolean``)
+**ConstructorInitializerAllOnOneLineOrOnePerLine** (``Boolean``) :versionbadge:`clang-format 3.7`
   This option is **deprecated**. See ``CurrentLine`` of
   ``PackConstructorInitializers``.
 
-**ConstructorInitializerIndentWidth** (``Unsigned``)
+**ConstructorInitializerIndentWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of characters to use for indentation of constructor
   initializer lists as well as inheritance lists.
 
-**ContinuationIndentWidth** (``Unsigned``)
+**ContinuationIndentWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   Indent width for line continuations.
 
   .. code-block:: c++
 
      ContinuationIndentWidth: 2
 
      int i =         //  VeryVeryVeryVeryVeryLongComment
        longFunction( // Again a long comment
          arg);
 
-**Cpp11BracedListStyle** (``Boolean``)
+**Cpp11BracedListStyle** (``Boolean``) :versionbadge:`clang-format 3.4`
   If ``true``, format braced lists as best suited for C++11 braced
   lists.
 
   Important differences:
   - No spaces inside the braced list.
   - No line break before the closing brace.
   - Indentation with the continuation indent, not with the block indent.
 
   Fundamentally, C++11 braced lists are formatted exactly like function
   calls would be formatted in their place. If the braced list follows a name
   (e.g. a type or variable name), clang-format formats as if the ``{}`` were
   the parentheses of a function call with that name. If there is no name,
   a zero-length name is assumed.
 
   .. code-block:: c++
 
      true:                                  false:
      vector<int> x{1, 2, 3, 4};     vs.     vector<int> x{ 1, 2, 3, 4 };
      vector<T> x{{}, {}, {}, {}};           vector<T> x{ {}, {}, {}, {} };
      f(MyMap[{composite, key}]);            f(MyMap[{ composite, key }]);
      new int[3]{1, 2, 3};                   new int[3]{ 1, 2, 3 };
 
-**DeriveLineEnding** (``Boolean``)
+**DeriveLineEnding** (``Boolean``) :versionbadge:`clang-format 11`
   Analyze the formatted file for the most used line ending (``\r\n``
   or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
 
-**DerivePointerAlignment** (``Boolean``)
+**DerivePointerAlignment** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, analyze the formatted file for the most common
   alignment of ``&`` and ``*``.
   Pointer and reference alignment styles are going to be updated according
   to the preferences found in the file.
   ``PointerAlignment`` is then used only as fallback.
 
-**DisableFormat** (``Boolean``)
+**DisableFormat** (``Boolean``) :versionbadge:`clang-format 3.7`
   Disables formatting completely.
 
-**EmptyLineAfterAccessModifier** (``EmptyLineAfterAccessModifierStyle``)
+**EmptyLineAfterAccessModifier** (``EmptyLineAfterAccessModifierStyle``) :versionbadge:`clang-format 14`
   Defines when to put an empty line after access modifiers.
   ``EmptyLineBeforeAccessModifier`` configuration handles the number of
   empty lines between two access modifiers.
 
   Possible values:
 
   * ``ELAAMS_Never`` (in configuration: ``Never``)
     Remove all empty lines after access modifiers.
.. code-block:: c++
       private:
 
       protected:
 
       };
 
 
 
-**EmptyLineBeforeAccessModifier** (``EmptyLineBeforeAccessModifierStyle``)
+**EmptyLineBeforeAccessModifier** (``EmptyLineBeforeAccessModifierStyle``) :versionbadge:`clang-format 13`
   Defines in which cases to put empty line before access modifiers.
 
   Possible values:
 
   * ``ELBAMS_Never`` (in configuration: ``Never``)
     Remove all empty lines before access modifiers.
 
     .. code-block:: c++
.. code-block:: c++
 
       private:
 
       protected:
       };
 
 
 
-**ExperimentalAutoDetectBinPacking** (``Boolean``)
+**ExperimentalAutoDetectBinPacking** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, clang-format detects whether function calls and
   definitions are formatted with one parameter per line.
 
   Each call can be bin-packed, one-per-line or inconclusive. If it is
   inconclusive, e.g. completely on one line, but a decision needs to be
   made, clang-format analyzes whether there are other bin-packed cases in
   the input file and act accordingly.
 
   NOTE: This is an experimental flag, that might go away or be renamed. Do
   not use this in config files, etc. Use at your own risk.
 
-**FixNamespaceComments** (``Boolean``)
+**FixNamespaceComments** (``Boolean``) :versionbadge:`clang-format 5`
   If ``true``, clang-format adds missing namespace end comments for
   short namespaces and fixes invalid existing ones. Short ones are
   controlled by "ShortNamespaceLines".
 
   .. code-block:: c++
 
      true:                                  false:
      namespace a {                  vs.     namespace a {
      foo();                                 foo();
      bar();                                 bar();
      } // namespace a                       }
 
-**ForEachMacros** (``List of Strings``)
+**ForEachMacros** (``List of Strings``) :versionbadge:`clang-format 3.7`
   A vector of macros that should be interpreted as foreach loops
   instead of as function calls.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     FOREACH(<variable-declaration>, ...)
       <loop-body>
 
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     ForEachMacros: ['RANGES_FOR', 'FOREACH']
 
   For example: BOOST_FOREACH.
 
-**IfMacros** (``List of Strings``)
+**IfMacros** (``List of Strings``) :versionbadge:`clang-format 14`
   A vector of macros that should be interpreted as conditionals
   instead of as function calls.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     IF(...)
       <conditional-body>
     else IF(...)
       <conditional-body>
 
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     IfMacros: ['IF']
 
   For example: `KJ_IF_MAYBE
   <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_
 
-**IncludeBlocks** (``IncludeBlocksStyle``)
+**IncludeBlocks** (``IncludeBlocksStyle``) :versionbadge:`clang-format 7`
   Dependent on the value, multiple ``#include`` blocks can be sorted
   as one and divided based on category.
 
   Possible values:
 
   * ``IBS_Preserve`` (in configuration: ``Preserve``)
     Sort each ``#include`` block separately.
 
.. code-block:: c++
 
        #include "b.h"               into      #include "a.h"
                                               #include "b.h"
        #include <lib/main.h>
        #include "a.h"                         #include <lib/main.h>
 
 
 
-**IncludeCategories** (``List of IncludeCategories``)
+**IncludeCategories** (``List of IncludeCategories``) :versionbadge:`clang-format 7`
   Regular expressions denoting the different ``#include`` categories
   used for ordering ``#includes``.
 
   `POSIX extended
   <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html>`_
   regular expressions are supported.
 
   These regular expressions are matched against the filename of an include
IncludeCategories:
       - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
         Priority:        3
       - Regex:           '<[[:alnum:].]+>'
         Priority:        4
       - Regex:           '.*'
         Priority:        1
         SortPriority:    0
 
-**IncludeIsMainRegex** (``String``)
+**IncludeIsMainRegex** (``String``) :versionbadge:`clang-format 7`
   Specify a regular expression of suffixes that are allowed in the
   file-to-main-include mapping.
 
   When guessing whether a #include is the "main" include (to assign
   category 0, see above), use this regex of allowed suffixes to the header
   stem. A partial match is done, so that:
   - "" means "arbitrary suffix"
   - "$" means "no suffix"
 
   For example, if configured to "(_test)?$", then a header a.h would be seen
   as the "main" include in both a.cc and a_test.cc.
 
-**IncludeIsMainSourceRegex** (``String``)
+**IncludeIsMainSourceRegex** (``String``) :versionbadge:`clang-format 7`
   Specify a regular expression for files being formatted
   that are allowed to be considered "main" in the
   file-to-main-include mapping.
 
   By default, clang-format considers files as "main" only when they end
   with: ``.c``, ``.cc``, ``.cpp``, ``.c++``, ``.cxx``, ``.m`` or ``.mm``
   extensions.
   For these files a guessing of "main" include takes place
   (to assign category 0, see above). This config option allows for
   additional suffixes and extensions for files to be considered as "main".
 
   For example, if this option is configured to ``(Impl\.hpp)$``,
   then a file ``ClassImpl.hpp`` is considered "main" (in addition to
   ``Class.c``, ``Class.cc``, ``Class.cpp`` and so on) and "main
   include file" logic will be executed (with *IncludeIsMainRegex* setting
   also being respected in later phase). Without this option set,
   ``ClassImpl.hpp`` would not have the main include file put on top
   before any other include.
 
-**IndentAccessModifiers** (``Boolean``)
+**IndentAccessModifiers** (``Boolean``) :versionbadge:`clang-format 13`
   Specify whether access modifiers should have their own indentation level.
 
   When ``false``, access modifiers are indented (or outdented) relative to
   the record members, respecting the ``AccessModifierOffset``. Record
   members are indented one level below the record.
   When ``true``, access modifiers get their own indentation level. As a
   consequence, record members are always indented 2 levels below the record,
   regardless of the access modifier presence. Value of the
class C {                      vs.     class C {
        };                                       };
      public:                                  public:
        C();                                     C();
      };                                     };
      void foo() {                           void foo() {
        return 1;                              return 1;
      }                                      }
 
-**IndentCaseBlocks** (``Boolean``)
+**IndentCaseBlocks** (``Boolean``) :versionbadge:`clang-format 11`
   Indent case label blocks one level from the case label.
 
   When ``false``, the block following the case label uses the same
   indentation level as for the case label, treating the case label the same
   as an if-statement.
   When ``true``, the block gets indented as a scope block.
 
   .. code-block:: c++
 
      false:                                 true:
      switch (fool) {                vs.     switch (fool) {
      case 1: {                              case 1:
        bar();                                 {
      } break;                                   bar();
      default: {                               }
        plop();                                break;
      }                                      default:
      }                                        {
                                                 plop();
                                               }
                                             }
 
-**IndentCaseLabels** (``Boolean``)
+**IndentCaseLabels** (``Boolean``) :versionbadge:`clang-format 3.3`
   Indent case labels one level from the switch statement.
 
   When ``false``, use the same indentation level as for the switch
   statement. Switch statement body is always indented one level more than
   case labels (except the first block following the case label, which
   itself indents the code - unless IndentCaseBlocks is enabled).
 
   .. code-block:: c++
 
      false:                                 true:
      switch (fool) {                vs.     switch (fool) {
      case 1:                                  case 1:
        bar();                                   bar();
        break;                                   break;
      default:                                 default:
        plop();                                  plop();
      }                                      }
 
-**IndentExternBlock** (``IndentExternBlockStyle``)
+**IndentExternBlock** (``IndentExternBlockStyle``) :versionbadge:`clang-format 12`
   IndentExternBlockStyle is the type of indenting of extern blocks.
 
   Possible values:
 
   * ``IEBS_AfterExternBlock`` (in configuration: ``AfterExternBlock``)
     Backwards compatible with AfterExternBlock's indenting.
 
     .. code-block:: c++
* ``IEBS_Indent`` (in configuration: ``Indent``)
     .. code-block:: c++
 
         extern "C" {
           void foo();
         }
 
 
 
-**IndentGotoLabels** (``Boolean``)
+**IndentGotoLabels** (``Boolean``) :versionbadge:`clang-format 10`
   Indent goto labels.
 
   When ``false``, goto labels are flushed left.
 
   .. code-block:: c++
 
      true:                                  false:
      int f() {                      vs.     int f() {
        if (foo()) {                           if (foo()) {
        label1:                              label1:
          bar();                                 bar();
        }                                      }
      label2:                                label2:
        return 1;                              return 1;
      }                                      }
 
-**IndentPPDirectives** (``PPDirectiveIndentStyle``)
+**IndentPPDirectives** (``PPDirectiveIndentStyle``) :versionbadge:`clang-format 6`
   The preprocessor directive indenting style to use.
 
   Possible values:
 
   * ``PPDIS_None`` (in configuration: ``None``)
     Does not indent any directives.
 
     .. code-block:: c++
.. code-block:: c++
        #if FOO
          #if BAR
            #include <foo>
          #endif
        #endif
 
 
 
-**IndentRequires** (``Boolean``)
+**IndentRequires** (``Boolean``) :versionbadge:`clang-format 13`
   Indent the requires clause in a template
 
   .. code-block:: c++
 
      true:
      template <typename It>
        requires Iterator<It>
      void sort(It begin, It end) {
        //....
      }
 
      false:
      template <typename It>
      requires Iterator<It>
      void sort(It begin, It end) {
        //....
      }
 
-**IndentWidth** (``Unsigned``)
+**IndentWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of columns to use for indentation.
 
   .. code-block:: c++
 
      IndentWidth: 3
 
      void f() {
         someFunction();
         if (true, false) {
            f();
         }
      }
 
-**IndentWrappedFunctionNames** (``Boolean``)
+**IndentWrappedFunctionNames** (``Boolean``) :versionbadge:`clang-format 3.7`
   Indent if a function definition or declaration is wrapped after the
   type.
 
   .. code-block:: c++
 
      true:
      LoooooooooooooooooooooooooooooooooooooooongReturnType
          LoooooooooooooooooooooooooooooooongFunctionDeclaration();
 
      false:
      LoooooooooooooooooooooooooooooooooooooooongReturnType
      LoooooooooooooooooooooooooooooooongFunctionDeclaration();
 
-**InsertTrailingCommas** (``TrailingCommaStyle``)
+**InsertTrailingCommas** (``TrailingCommaStyle``) :versionbadge:`clang-format 12`
   If set to ``TCS_Wrapped`` will insert trailing commas in container
   literals (arrays and objects) that wrap across multiple lines.
   It is currently only available for JavaScript
   and disabled by default ``TCS_None``.
   ``InsertTrailingCommas`` cannot be used together with ``BinPackArguments``
   as inserting the comma disables bin-packing.
 
   .. code-block:: c++
* ``TCS_Wrapped`` (in configuration: ``Wrapped``)
     Insert trailing commas in container literals that were wrapped over
     multiple lines. Note that this is conceptually incompatible with
     bin-packing, because the trailing comma is used as an indicator
     that a container should be formatted one-per-line (i.e. not bin-packed).
     So inserting a trailing comma counteracts bin-packing.
 
 
 
-**JavaImportGroups** (``List of Strings``)
+**JavaImportGroups** (``List of Strings``) :versionbadge:`clang-format 8`
   A vector of prefixes ordered by the desired groups for Java imports.
 
   One group's prefix can be a subset of another - the longest prefix is
   always matched. Within a group, the imports are ordered lexicographically.
   Static imports are grouped separately and follow the same group rules.
   By default, static imports are placed before non-static imports,
   but this behavior is changed by another option,
   ``SortJavaStaticImport``.
.. code-block:: java
      import com.example.ClassA;
      import com.example.Test;
      import com.example.a.ClassB;
 
      import com.test.ClassC;
 
      import org.example.ClassD;
 
-**JavaScriptQuotes** (``JavaScriptQuoteStyle``)
+**JavaScriptQuotes** (``JavaScriptQuoteStyle``) :versionbadge:`clang-format 3.9`
   The JavaScriptQuoteStyle to use for JavaScript strings.
 
   Possible values:
 
   * ``JSQS_Leave`` (in configuration: ``Leave``)
     Leave string quotes as they are.
 
     .. code-block:: js
* ``JSQS_Double`` (in configuration: ``Double``)
 
     .. code-block:: js
 
        string1 = "foo";
        string2 = "bar";
 
 
 
-**JavaScriptWrapImports** (``Boolean``)
+**JavaScriptWrapImports** (``Boolean``) :versionbadge:`clang-format 3.9`
   Whether to wrap JavaScript import/export statements.
 
   .. code-block:: js
 
      true:
      import {
          VeryLongImportsAreAnnoying,
          VeryLongImportsAreAnnoying,
          VeryLongImportsAreAnnoying,
      } from 'some/module.js'
 
      false:
      import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
 
-**KeepEmptyLinesAtTheStartOfBlocks** (``Boolean``)
+**KeepEmptyLinesAtTheStartOfBlocks** (``Boolean``) :versionbadge:`clang-format 3.7`
   If true, the empty line at the start of blocks is kept.
 
   .. code-block:: c++
 
      true:                                  false:
      if (foo) {                     vs.     if (foo) {
                                               bar();
        bar();                               }
      }
 
-**LambdaBodyIndentation** (``LambdaBodyIndentationKind``)
+**LambdaBodyIndentation** (``LambdaBodyIndentationKind``) :versionbadge:`clang-format 13`
   The indentation style of lambda bodies. ``Signature`` (the default)
   causes the lambda body to be indented one additional level relative to
   the indentation level of the signature. ``OuterScope`` forces the lambda
   body to be indented one additional level relative to the parent scope
   containing the lambda signature. For callback-heavy code, it may improve
   readability to have the signature indented two levels and to use
   ``OuterScope``. The KJ style guide requires ``OuterScope``.
   `KJ style guide
.. code-block:: c++
 
        someMethod(
            [](SomeReallyLongLambdaSignatureArgument foo) {
          return;
        });
 
 
 
-**Language** (``LanguageKind``)
+**Language** (``LanguageKind``) :versionbadge:`clang-format 3.5`
   Language, this format style is targeted at.
 
   Possible values:
 
   * ``LK_None`` (in configuration: ``None``)
     Do not use.
 
   * ``LK_Cpp`` (in configuration: ``Cpp``)
* ``LK_TableGen`` (in configuration: ``TableGen``)
     Should be used for TableGen code.
 
   * ``LK_TextProto`` (in configuration: ``TextProto``)
     Should be used for Protocol Buffer messages in text format
     (https://developers.google.com/protocol-buffers/).
 
 
 
-**MacroBlockBegin** (``String``)
+**MacroBlockBegin** (``String``) :versionbadge:`clang-format 3.7`
   A regular expression matching macros that start a block.
 
   .. code-block:: c++
 
      # With:
      MacroBlockBegin: "^NS_MAP_BEGIN|\
      NS_TABLE_HEAD$"
      MacroBlockEnd: "^\
.. code-block:: c++
      NS_MAP_BEGIN
      foo();
      NS_MAP_END
 
      NS_TABLE_HEAD
      bar();
      NS_TABLE_FOO_END
 
-**MacroBlockEnd** (``String``)
+**MacroBlockEnd** (``String``) :versionbadge:`clang-format 3.7`
   A regular expression matching macros that end a block.
 
-**MaxEmptyLinesToKeep** (``Unsigned``)
+**MaxEmptyLinesToKeep** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The maximum number of consecutive empty lines to keep.
 
   .. code-block:: c++
 
      MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
      int f() {                              int f() {
        int = 1;                                 int i = 1;
                                                 i = foo();
        i = foo();                               return i;
                                             }
        return i;
      }
 
-**NamespaceIndentation** (``NamespaceIndentationKind``)
+**NamespaceIndentation** (``NamespaceIndentationKind``) :versionbadge:`clang-format 3.7`
   The indentation used for namespaces.
 
   Possible values:
 
   * ``NI_None`` (in configuration: ``None``)
     Don't indent in namespaces.
 
     .. code-block:: c++
.. code-block:: c++
          int i;
          namespace in {
            int i;
          }
        }
 
 
 
-**NamespaceMacros** (``List of Strings``)
+**NamespaceMacros** (``List of Strings``) :versionbadge:`clang-format 9`
   A vector of macros which are used to open namespace blocks.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     NAMESPACE(<namespace-name>, ...) {
       <namespace-content>
     }
 
   For example: TESTSUITE
 
-**ObjCBinPackProtocolList** (``BinPackStyle``)
+**ObjCBinPackProtocolList** (``BinPackStyle``) :versionbadge:`clang-format 7`
   Controls bin-packing Objective-C protocol conformance list
   items into as few lines as possible when they go over ``ColumnLimit``.
 
   If ``Auto`` (the default), delegates to the value in
   ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
   protocol conformance list items into as few lines as possible
   whenever they go over ``ColumnLimit``.
 
**ObjCBinPackProtocolList** (``BinPackStyle``) :versionbadge:`clang-format 7`
   * ``BPS_Always`` (in configuration: ``Always``)
     Always bin-pack parameters.
 
   * ``BPS_Never`` (in configuration: ``Never``)
     Never bin-pack parameters.
 
 
 
-**ObjCBlockIndentWidth** (``Unsigned``)
+**ObjCBlockIndentWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of characters to use for indentation of ObjC blocks.
 
   .. code-block:: objc
 
      ObjCBlockIndentWidth: 4
 
      [operation setCompletionBlock:^{
          [self onOperationDone];
      }];
 
-**ObjCBreakBeforeNestedBlockParam** (``Boolean``)
+**ObjCBreakBeforeNestedBlockParam** (``Boolean``) :versionbadge:`clang-format 12`
   Break parameters list into lines when there is nested block
   parameters in a function call.
 
   .. code-block:: c++
 
     false:
      - (void)_aMethod
      {
          [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber
          *u, NSNumber *v) {
              u = c;
          }]
      }
      true:
      - (void)_aMethod
      {
         [self.test1 t:self
                      w:self
             callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
                  u = c;
              }]
      }
 
-**ObjCSpaceAfterProperty** (``Boolean``)
+**ObjCSpaceAfterProperty** (``Boolean``) :versionbadge:`clang-format 3.7`
   Add a space after ``@property`` in Objective-C, i.e. use
   ``@property (readonly)`` instead of ``@property(readonly)``.
 
-**ObjCSpaceBeforeProtocolList** (``Boolean``)
+**ObjCSpaceBeforeProtocolList** (``Boolean``) :versionbadge:`clang-format 3.7`
   Add a space in front of an Objective-C protocol list, i.e. use
   ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
 
-**PPIndentWidth** (``Integer``)
+**PPIndentWidth** (``Integer``) :versionbadge:`clang-format 14`
   The number of columns to use for indentation of preprocessor statements.
   When set to -1 (default) ``IndentWidth`` is used also for preprocessor
   statements.
 
   .. code-block:: c++
 
      PPIndentWidth: 1
 
      #ifdef __linux__
      # define FOO
      #else
      # define BAR
      #endif
 
-**PackConstructorInitializers** (``PackConstructorInitializersStyle``)
+**PackConstructorInitializers** (``PackConstructorInitializersStyle``) :versionbadge:`clang-format 14`
   The pack constructor initializers style to use.
 
   Possible values:
 
   * ``PCIS_Never`` (in configuration: ``Never``)
     Always put each constructor initializer on its own line.
 
     .. code-block:: c++
.. code-block:: c++
 
        Constructor()
            : aaaaaaaaaaaaaaaaaaaa(),
              bbbbbbbbbbbbbbbbbbbb(),
              cccccccccccccccccccc()
 
 
 
-**PenaltyBreakAssignment** (``Unsigned``)
+**PenaltyBreakAssignment** (``Unsigned``) :versionbadge:`clang-format 5`
   The penalty for breaking around an assignment operator.
 
-**PenaltyBreakBeforeFirstCallParameter** (``Unsigned``)
+**PenaltyBreakBeforeFirstCallParameter** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for breaking a function call after ``call(``.
 
-**PenaltyBreakComment** (``Unsigned``)
+**PenaltyBreakComment** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for each line break introduced inside a comment.
 
-**PenaltyBreakFirstLessLess** (``Unsigned``)
+**PenaltyBreakFirstLessLess** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for breaking before the first ``<<``.
 
-**PenaltyBreakString** (``Unsigned``)
+**PenaltyBreakString** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for each line break introduced inside a string literal.
 
-**PenaltyBreakTemplateDeclaration** (``Unsigned``)
+**PenaltyBreakTemplateDeclaration** (``Unsigned``) :versionbadge:`clang-format 7`
   The penalty for breaking after template declaration.
 
-**PenaltyExcessCharacter** (``Unsigned``)
+**PenaltyExcessCharacter** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The penalty for each character outside of the column limit.
 
-**PenaltyIndentedWhitespace** (``Unsigned``)
+**PenaltyIndentedWhitespace** (``Unsigned``) :versionbadge:`clang-format 13`
   Penalty for each character of whitespace indentation
   (counted relative to leading non-whitespace column).
 
-**PenaltyReturnTypeOnItsOwnLine** (``Unsigned``)
+**PenaltyReturnTypeOnItsOwnLine** (``Unsigned``) :versionbadge:`clang-format 3.7`
   Penalty for putting the return type of a function onto its own
   line.
 
-**PointerAlignment** (``PointerAlignmentStyle``)
+**PointerAlignment** (``PointerAlignmentStyle``) :versionbadge:`clang-format 3.7`
   Pointer and reference alignment style.
 
   Possible values:
 
   * ``PAS_Left`` (in configuration: ``Left``)
     Align pointer to the left.
 
     .. code-block:: c++
* ``PAS_Middle`` (in configuration: ``Middle``)
     Align pointer in the middle.
 
     .. code-block:: c++
 
       int * a;
 
 
 
-**QualifierAlignment** (``QualifierAlignmentStyle``)
+**QualifierAlignment** (``QualifierAlignmentStyle``) :versionbadge:`clang-format 14`
   Different ways to arrange const/volatile qualifiers.
 
   .. warning:: 
 
    ``QualifierAlignment`` COULD lead to incorrect code generation.
 
   Possible values:
 
* ``QAS_Custom`` (in configuration: ``Custom``)
     .. code-block:: c++
 
 
        int const a;
        int const *a;
 
 
 
-**QualifierOrder** (``List of Strings``)
+**QualifierOrder** (``List of Strings``) :versionbadge:`clang-format 14`
   The Order in which the qualifiers appear.
   Order is a an array can contain any of the following
 
     * const
     * inline
     * static
     * constexpr
     * volatile
     * restrict
     * type
 
   Note: it MUST contain 'type'.
   Items to the left of type will be aligned in the order supplied.
   Items to the right of type will be aligned  in the order supplied.
 
 
   .. code-block:: yaml
 
     QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
 
-**RawStringFormats** (``List of RawStringFormats``)
+**RawStringFormats** (``List of RawStringFormats``) :versionbadge:`clang-format 6`
   Defines hints for detecting supported languages code blocks in raw
   strings.
 
   A raw string with a matching delimiter or a matching enclosing function
   name will be reformatted assuming the specified language based on the
   style for that language defined in the .clang-format file. If no style has
   been defined in the .clang-format file for the specific language, a
   predefined style given by 'BasedOnStyle' is used. If 'BasedOnStyle' is not
RawStringFormats:
           BasedOnStyle: google
       - Language: Cpp
           Delimiters:
             - 'cc'
             - 'cpp'
           BasedOnStyle: llvm
           CanonicalDelimiter: 'cc'
 
-**ReferenceAlignment** (``ReferenceAlignmentStyle``)
+**ReferenceAlignment** (``ReferenceAlignmentStyle``) :versionbadge:`clang-format 14`
   Reference alignment style (overrides ``PointerAlignment`` for
   references).
 
   Possible values:
 
   * ``RAS_Pointer`` (in configuration: ``Pointer``)
     Align reference like ``PointerAlignment``.
 
* ``RAS_Middle`` (in configuration: ``Middle``)
     Align reference in the middle.
 
     .. code-block:: c++
 
       int & a;
 
 
 
-**ReflowComments** (``Boolean``)
+**ReflowComments** (``Boolean``) :versionbadge:`clang-format 4`
   If ``true``, clang-format will attempt to re-flow comments.
 
   .. code-block:: c++
 
      false:
      // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
 
      true:
      // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
      // information
      /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
       * information */
 
-**ShortNamespaceLines** (``Unsigned``)
+**ShortNamespaceLines** (``Unsigned``) :versionbadge:`clang-format 14`
   The maximal number of unwrapped lines that a short namespace spans.
   Defaults to 1.
 
   This determines the maximum length of short namespaces by counting
   unwrapped lines (i.e. containing neither opening nor closing
   namespace brace) and makes "FixNamespaceComments" omit adding
   end comments for those.
 
   .. code-block:: c++
 
      ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
      namespace a {                      namespace a {
        int foo;                           int foo;
      }                                  } // namespace a
 
      ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
      namespace b {                      namespace b {
        int foo;                           int foo;
        int bar;                           int bar;
      } // namespace b                   } // namespace b
 
-**SortIncludes** (``SortIncludesOptions``)
+**SortIncludes** (``SortIncludesOptions``) :versionbadge:`clang-format 4`
   Controls if and how clang-format will sort ``#includes``.
   If ``Never``, includes are never sorted.
   If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
   insensitive fashion.
   If ``CaseSensitive``, includes are sorted in an alphabetical or case
   sensitive fashion.
 
   Possible values:
.. code-block:: c++
        #include "A/B.h"
        #include "A/b.h"
        #include "a/b.h"
        #include "B/A.h"
        #include "B/a.h"
 
 
 
-**SortJavaStaticImport** (``SortJavaStaticImportOptions``)
+**SortJavaStaticImport** (``SortJavaStaticImportOptions``) :versionbadge:`clang-format 13`
   When sorting Java imports, by default static imports are placed before
   non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   static imports are placed after non-static imports.
 
   Possible values:
 
   * ``SJSIO_Before`` (in configuration: ``Before``)
     Static imports are placed before non-static imports.
* ``SJSIO_After`` (in configuration: ``After``)
     .. code-block:: java
 
       import org.example.ClassA;
 
       import static org.example.function1;
 
 
 
-**SortUsingDeclarations** (``Boolean``)
+**SortUsingDeclarations** (``Boolean``) :versionbadge:`clang-format 5`
   If ``true``, clang-format will sort using declarations.
 
   The order of using declarations is defined as follows:
   Split the strings by "::" and discard any initial empty strings. The last
   element of each list is a non-namespace name; all others are namespace
   names. Sort the lists of names lexicographically, where the sort order of
   individual names is that all non-namespace names come before all namespace
   names, and within those groups, names are in case-insensitive
   lexicographic order.
 
   .. code-block:: c++
 
      false:                                 true:
      using std::cout;               vs.     using std::cin;
      using std::cin;                        using std::cout;
 
-**SpaceAfterCStyleCast** (``Boolean``)
+**SpaceAfterCStyleCast** (``Boolean``) :versionbadge:`clang-format 3.5`
   If ``true``, a space is inserted after C style casts.
 
   .. code-block:: c++
 
      true:                                  false:
      (int) i;                       vs.     (int)i;
 
-**SpaceAfterLogicalNot** (``Boolean``)
+**SpaceAfterLogicalNot** (``Boolean``) :versionbadge:`clang-format 9`
   If ``true``, a space is inserted after the logical not operator (``!``).
 
   .. code-block:: c++
 
      true:                                  false:
      ! someExpression();            vs.     !someExpression();
 
-**SpaceAfterTemplateKeyword** (``Boolean``)
+**SpaceAfterTemplateKeyword** (``Boolean``) :versionbadge:`clang-format 4`
   If ``true``, a space will be inserted after the 'template' keyword.
 
   .. code-block:: c++
 
      true:                                  false:
      template <int> void foo();     vs.     template<int> void foo();
 
-**SpaceAroundPointerQualifiers** (``SpaceAroundPointerQualifiersStyle``)
+**SpaceAroundPointerQualifiers** (``SpaceAroundPointerQualifiersStyle``) :versionbadge:`clang-format 13`
   Defines in which cases to put a space before or after pointer qualifiers
 
   Possible values:
 
   * ``SAPQ_Default`` (in configuration: ``Default``)
     Don't ensure spaces around pointer qualifiers and use PointerAlignment
     instead.
 
* ``SAPQ_Both`` (in configuration: ``Both``)
 
     .. code-block:: c++
 
        PointerAlignment: Left                 PointerAlignment: Right
        void* const * x = NULL;         vs.     void * const *x = NULL;
 
 
 
-**SpaceBeforeAssignmentOperators** (``Boolean``)
+**SpaceBeforeAssignmentOperators** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``false``, spaces will be removed before assignment operators.
 
   .. code-block:: c++
 
      true:                                  false:
      int a = 5;                     vs.     int a= 5;
      a += 42;                               a+= 42;
 
-**SpaceBeforeCaseColon** (``Boolean``)
+**SpaceBeforeCaseColon** (``Boolean``) :versionbadge:`clang-format 13`
   If ``false``, spaces will be removed before case colon.
 
   .. code-block:: c++
 
     true:                                   false
     switch (x) {                    vs.     switch (x) {
       case 1 : break;                         case 1: break;
     }                                       }
 
-**SpaceBeforeCpp11BracedList** (``Boolean``)
+**SpaceBeforeCpp11BracedList** (``Boolean``) :versionbadge:`clang-format 7`
   If ``true``, a space will be inserted before a C++11 braced list
   used to initialize an object (after the preceding identifier or type).
 
   .. code-block:: c++
 
      true:                                  false:
      Foo foo { bar };               vs.     Foo foo{ bar };
      Foo {};                                Foo{};
      vector<int> { 1, 2, 3 };               vector<int>{ 1, 2, 3 };
      new int[3] { 1, 2, 3 };                new int[3]{ 1, 2, 3 };
 
-**SpaceBeforeCtorInitializerColon** (``Boolean``)
+**SpaceBeforeCtorInitializerColon** (``Boolean``) :versionbadge:`clang-format 7`
   If ``false``, spaces will be removed before constructor initializer
   colon.
 
   .. code-block:: c++
 
      true:                                  false:
      Foo::Foo() : a(a) {}                   Foo::Foo(): a(a) {}
 
-**SpaceBeforeInheritanceColon** (``Boolean``)
+**SpaceBeforeInheritanceColon** (``Boolean``) :versionbadge:`clang-format 7`
   If ``false``, spaces will be removed before inheritance colon.
 
   .. code-block:: c++
 
      true:                                  false:
      class Foo : Bar {}             vs.     class Foo: Bar {}
 
-**SpaceBeforeParens** (``SpaceBeforeParensOptions``)
+**SpaceBeforeParens** (``SpaceBeforeParensOptions``) :versionbadge:`clang-format 3.5`
   Defines in which cases to put a space before opening parentheses.
 
   Possible values:
 
   * ``SBPO_Never`` (in configuration: ``Never``)
     Never put a space before opening parentheses.
 
     .. code-block:: c++
.. code-block:: c++
        void f () {
          if (true) {
            f ();
          }
        }
 
 
 
-**SpaceBeforeRangeBasedForLoopColon** (``Boolean``)
+**SpaceBeforeRangeBasedForLoopColon** (``Boolean``) :versionbadge:`clang-format 7`
   If ``false``, spaces will be removed before range-based for loop
   colon.
 
   .. code-block:: c++
 
      true:                                  false:
      for (auto v : values) {}       vs.     for(auto v: values) {}
 
-**SpaceBeforeSquareBrackets** (``Boolean``)
+**SpaceBeforeSquareBrackets** (``Boolean``) :versionbadge:`clang-format 11`
   If ``true``, spaces will be before  ``[``.
   Lambdas will not be affected. Only the first ``[`` will get a space added.
 
   .. code-block:: c++
 
      true:                                  false:
      int a [5];                    vs.      int a[5];
      int a [5][5];                 vs.      int a[5][5];
 
-**SpaceInEmptyBlock** (``Boolean``)
+**SpaceInEmptyBlock** (``Boolean``) :versionbadge:`clang-format 11`
   If ``true``, spaces will be inserted into ``{}``.
 
   .. code-block:: c++
 
      true:                                false:
      void f() { }                   vs.   void f() {}
      while (true) { }                     while (true) {}
 
-**SpaceInEmptyParentheses** (``Boolean``)
+**SpaceInEmptyParentheses** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces may be inserted into ``()``.
 
   .. code-block:: c++
 
      true:                                false:
      void f( ) {                    vs.   void f() {
        int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
        if (true) {                          if (true) {
          f( );                                f();
        }                                    }
      }                                    }
 
-**SpacesBeforeTrailingComments** (``Unsigned``)
+**SpacesBeforeTrailingComments** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of spaces before trailing line comments
   (``//`` - comments).
 
   This does not affect trailing block comments (``/*`` - comments) as
   those commonly have different usage patterns and a number of special
   cases.
 
   .. code-block:: c++
 
      SpacesBeforeTrailingComments: 3
      void f() {
        if (true) {   // foo1
          f();        // bar
        }             // foo
      }
 
-**SpacesInAngles** (``SpacesInAnglesStyle``)
+**SpacesInAngles** (``SpacesInAnglesStyle``) :versionbadge:`clang-format 14`
   The SpacesInAnglesStyle to use for template argument lists.
 
   Possible values:
 
   * ``SIAS_Never`` (in configuration: ``Never``)
     Remove spaces after ``<`` and before ``>``.
 
     .. code-block:: c++
.. code-block:: c++
        std::function< void(int) > fct;
 
   * ``SIAS_Leave`` (in configuration: ``Leave``)
     Keep a single space after ``<`` and before ``>`` if any spaces were
     present. Option ``Standard: Cpp03`` takes precedence.
 
 
 
-**SpacesInCStyleCastParentheses** (``Boolean``)
+**SpacesInCStyleCastParentheses** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces may be inserted into C style casts.
 
   .. code-block:: c++
 
      true:                                  false:
      x = ( int32 )y                 vs.     x = (int32)y
 
-**SpacesInConditionalStatement** (``Boolean``)
+**SpacesInConditionalStatement** (``Boolean``) :versionbadge:`clang-format 11`
   If ``true``, spaces will be inserted around if/for/switch/while
   conditions.
 
   .. code-block:: c++
 
      true:                                  false:
      if ( a )  { ... }              vs.     if (a) { ... }
      while ( i < 5 )  { ... }               while (i < 5) { ... }
 
-**SpacesInContainerLiterals** (``Boolean``)
+**SpacesInContainerLiterals** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces are inserted inside container literals (e.g.
   ObjC and Javascript array and dict literals).
 
   .. code-block:: js
 
      true:                                  false:
      var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
      f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
 
-**SpacesInLineCommentPrefix** (``SpacesInLineComment``)
+**SpacesInLineCommentPrefix** (``SpacesInLineComment``) :versionbadge:`clang-format 14`
   How many spaces are allowed at the start of a line comment. To disable the
   maximum set it to ``-1``, apart from that the maximum takes precedence
   over the minimum.
   Minimum = 1 Maximum = -1
   // One space is forced
 
   //  but more spaces are possible
 
**SpacesInLineCommentPrefix** (``SpacesInLineComment``) :versionbadge:`clang-format 14`
   Nested configuration flags:
 
 
   * ``unsigned Minimum`` The minimum number of spaces at the start of the comment.
 
   * ``unsigned Maximum`` The maximum number of spaces at the start of the comment.
 
 
-**SpacesInParentheses** (``Boolean``)
+**SpacesInParentheses** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces will be inserted after ``(`` and before ``)``.
 
   .. code-block:: c++
 
      true:                                  false:
      t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
 
-**SpacesInSquareBrackets** (``Boolean``)
+**SpacesInSquareBrackets** (``Boolean``) :versionbadge:`clang-format 3.7`
   If ``true``, spaces will be inserted after ``[`` and before ``]``.
   Lambdas without arguments or unspecified size array declarations will not
   be affected.
 
   .. code-block:: c++
 
      true:                                  false:
      int a[ 5 ];                    vs.     int a[5];
      std::unique_ptr<int[]> foo() {} // Won't be affected
 
-**Standard** (``LanguageStandard``)
+**Standard** (``LanguageStandard``) :versionbadge:`clang-format 3.7`
   Parse and format C++ constructs compatible with this standard.
 
   .. code-block:: c++
 
      c++03:                                 latest:
      vector<set<int> > x;           vs.     vector<set<int>> x;
 
   Possible values:
* ``LS_Latest`` (in configuration: ``Latest``)
     Parse and format using the latest supported language version.
     ``Cpp11`` is a deprecated alias for ``Latest``
 
   * ``LS_Auto`` (in configuration: ``Auto``)
     Automatic detection based on the input.
 
 
 
-**StatementAttributeLikeMacros** (``List of Strings``)
+**StatementAttributeLikeMacros** (``List of Strings``) :versionbadge:`clang-format 13`
   Macros which are ignored in front of a statement, as if they were an
   attribute. So that they are not parsed as identifier, for example for Qts
   emit.
 
   .. code-block:: c++
 
     AlignConsecutiveDeclarations: true
     StatementAttributeLikeMacros: []
     unsigned char data = 'x';
     emit          signal(data); // This is parsed as variable declaration.
 
     AlignConsecutiveDeclarations: true
     StatementAttributeLikeMacros: [emit]
     unsigned char data = 'x';
     emit signal(data); // Now it's fine again.
 
-**StatementMacros** (``List of Strings``)
+**StatementMacros** (``List of Strings``) :versionbadge:`clang-format 8`
   A vector of macros that should be interpreted as complete
   statements.
 
   Typical macros are expressions, and require a semi-colon to be
   added; sometimes this is not the case, and this allows to make
   clang-format aware of such cases.
 
   For example: Q_UNUSED
 
-**TabWidth** (``Unsigned``)
+**TabWidth** (``Unsigned``) :versionbadge:`clang-format 3.7`
   The number of columns used for tab stops.
 
-**TypenameMacros** (``List of Strings``)
+**TypenameMacros** (``List of Strings``) :versionbadge:`clang-format 9`
   A vector of macros that should be interpreted as type declarations
   instead of as function calls.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     STACK_OF(...)
 
   In the .clang-format configuration file, this can be configured like:
 
   .. code-block:: yaml
 
     TypenameMacros: ['STACK_OF', 'LIST']
 
   For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
 
-**UseCRLF** (``Boolean``)
+**UseCRLF** (``Boolean``) :versionbadge:`clang-format 11`
   Use ``\r\n`` instead of ``\n`` for line breaks.
   Also used as fallback if ``DeriveLineEnding`` is true.
 
-**UseTab** (``UseTabStyle``)
+**UseTab** (``UseTabStyle``) :versionbadge:`clang-format 3.7`
   The way to use tab characters in the resulting file.
 
   Possible values:
 
   * ``UT_Never`` (in configuration: ``Never``)
     Never use tab.
 
   * ``UT_ForIndentation`` (in configuration: ``ForIndentation``)
     Use tabs only for indentation.
 
   * ``UT_ForContinuationAndIndentation`` (in configuration: ``ForContinuationAndIndentation``)
     Fill all leading whitespace with tabs, and use spaces for alignment that
     appears within a line (e.g. consecutive assignments and declarations).
 
   * ``UT_AlignWithSpaces`` (in configuration: ``AlignWithSpaces``)
     Use tabs for line continuation and indentation, and spaces for
     alignment.
 
   * ``UT_Always`` (in configuration: ``Always``)
     Use tabs whenever we need to fill whitespace that spans at least from
     one tab stop to the next one.
 
 
 
-**WhitespaceSensitiveMacros** (``List of Strings``)
+**WhitespaceSensitiveMacros** (``List of Strings``) :versionbadge:`clang-format 12`
   A vector of macros which are whitespace-sensitive and should not
   be touched.
 
   These are expected to be macros of the form:
 
   .. code-block:: c++
 
     STRINGIZE(...)

clang/docs/tools/dump_format_style.py

 def indent(text, columns, indent_first_line=True):
   indent = ' ' * columns
   s = re.sub(r'\n([^\n])', '\n' + indent + '\\1', text, flags=re.S)
   if not indent_first_line or s.startswith('\n'):
     return s
   return indent + s
 
 class Option(object):
-  def __init__(self, name, type, comment):
+  def __init__(self, name, type, comment, version):
     self.name = name
     self.type = type
     self.comment = comment.strip()
     self.enum = None
     self.nested_struct = None
+    self.version = version
 
   def __str__(self):
+    if self.version:
+      s = '**%s** (``%s``) :versionbadge:`clang-format %s`\n%s' % (self.name, to_yaml_type(self.type), self.version,
+                                 doxygen2rst(indent(self.comment, 2)))
+    else:
       s = '**%s** (``%s``)\n%s' % (self.name, to_yaml_type(self.type),
                                  doxygen2rst(indent(self.comment, 2)))
     if self.enum and self.enum.values:
       s += indent('\n\nPossible values:\n\n%s\n' % self.enum, 2)
     if self.nested_struct:
       s += indent('\n\nNested configuration flags:\n\n%s\n' %self.nested_struct,
                   2)
     return s
 
def read_options(header):
   state = State.BeforeStruct
 
   options = []
   enums = {}
   nested_structs = {}
   comment = ''
   enum = None
   nested_struct = None
+  version = None
 
   for line in header:
     line = line.strip()
     if state == State.BeforeStruct:
       if line == 'struct FormatStyle {' or line == 'struct IncludeStyle {':
         state = State.InStruct
     elif state == State.InStruct:
       if line.startswith('///'):
         state = State.InFieldComment
         comment = clean_comment_line(line)
       elif line == '};':
         state = State.Finished
         break
     elif state == State.InFieldComment:
-      if line.startswith('///'):
+      if line.startswith(r'/// \version'):
+        match = re.match(r'/// \\version\s*(?P<version>[0-9.]+)*',line)
+        if match:
+            version = match.group('version')
+      elif line.startswith('///'):
         comment += clean_comment_line(line)
       elif line.startswith('enum'):
         state = State.InEnum
         name = re.sub(r'enum\s+(\w+)\s*(:((\s*\w+)+)\s*)?\{', '\\1', line)
         enum = Enum(name, comment)
       elif line.startswith('struct'):
         state = State.InNestedStruct
         name = re.sub(r'struct\s+(\w+)\s*\{', '\\1', line)
         nested_struct = NestedStruct(name, comment)
       elif line.endswith(';'):
         state = State.InStruct
         field_type, field_name = re.match(r'([<>:\w(,\s)]+)\s+(\w+);',
                                           line).groups()
-        option = Option(str(field_name), str(field_type), comment)
+
+        if not version:
+            print('Warning missing version for ', field_name)
+        option = Option(str(field_name), str(field_type), comment, version)
         options.append(option)
+        version=None
       else:
-        raise Exception('Invalid format, expected comment, field or enum')
+        raise Exception('Invalid format, expected comment, field or enum\n'+line)
     elif state == State.InNestedStruct:
       if line.startswith('///'):
         state = State.InNestedFieldComment
         comment = clean_comment_line(line)
       elif line == '};':
         state = State.InStruct
         nested_structs[nested_struct.name] = nested_struct
     elif state == State.InNestedFieldComment:

clang/include/clang/Format/Format.h

 /// specific guidelines.
 struct FormatStyle {
   // If the BasedOn: was InheritParentConfig and this style needs the file from
   // the parent directories. It is not part of the actual style for formatting.
   // Thus the // instead of ///.
   bool InheritsParentConfig;
 
   /// The extra indent or outdent of access modifiers, e.g. ``public:``.
+  /// \version 3.3
   int AccessModifierOffset;
 
   /// Different styles for aligning after open brackets.
   enum BracketAlignmentStyle : unsigned char {
     /// Align parameters on the open bracket, e.g.:
     /// \code
     ///   someLongFunction(argument1,
     ///                    argument2);
enum BracketAlignmentStyle : unsigned char {
     /// \endcode
     BAS_AlwaysBreak,
   };
 
   /// If ``true``, horizontally aligns arguments after an open bracket.
   ///
   /// This applies to round brackets (parentheses), angle brackets and square
   /// brackets.
+  /// \version 3.8
   BracketAlignmentStyle AlignAfterOpenBracket;
 
   /// Different style for aligning array initializers.
   enum ArrayInitializerAlignmentStyle {
     /// Align array column and left justify the columns e.g.:
     /// \code
     ///   struct test demo[] =
     ///   {
enum ArrayInitializerAlignmentStyle {
     ///   };
     /// \endcode
     AIAS_Right,
     /// Don't align array initializer columns.
     AIAS_None
   };
   /// if not ``None``, when using initialization for an array of structs
   /// aligns the fields into columns.
+  /// \version 13
   ArrayInitializerAlignmentStyle AlignArrayOfStructures;
 
   /// Styles for alignment of consecutive tokens. Tokens can be assignment signs
   /// (see
   /// ``AlignConsecutiveAssignments``), bitfield member separators (see
   /// ``AlignConsecutiveBitFields``), names in declarations (see
   /// ``AlignConsecutiveDeclarations``) or macro definitions (see
   /// ``AlignConsecutiveMacros``).
struct FormatStyle {
   ///      #define SHORT_NAME       42
   ///      #define LONGER_NAME      0x007f
   ///      #define EVEN_LONGER_NAME (2)
   ///
   ///      #define foo(x)           (x * x)
   ///      /* some comment */
   ///      #define bar(y, z)        (y + z)
   ///    \endcode
+  /// \version 13
   AlignConsecutiveStyle AlignConsecutiveMacros;
 
   /// Style of aligning consecutive assignments.
   ///
   /// ``Consecutive`` will result in formattings like:
   /// \code
   ///   int a            = 1;
   ///   int somelongname = 2;
struct FormatStyle {
   ///      int a            = 1;
   ///      int somelongname = 2;
   ///      double c         = 3;
   ///
   ///      int d            = 3;
   ///      /* A comment. */
   ///      double e         = 4;
   ///    \endcode
+  /// \version 13
   AlignConsecutiveStyle AlignConsecutiveAssignments;
 
   /// Style of aligning consecutive bit field.
   ///
   /// ``Consecutive`` will align the bitfield separators of consecutive lines.
   /// This will result in formattings like:
   /// \code
   ///   int aaaa : 1;
struct FormatStyle {
   ///      int aaaa : 1;
   ///      int b    : 12;
   ///      int ccc  : 8;
   ///
   ///      int d    : 2;
   ///      /* A comment. */
   ///      int ee   : 3;
   ///    \endcode
+  /// \version 13
   AlignConsecutiveStyle AlignConsecutiveBitFields;
 
   /// Style of aligning consecutive declarations.
   ///
   /// ``Consecutive`` will align the declaration names of consecutive lines.
   /// This will result in formattings like:
   /// \code
   ///   int         aaaa = 12;
struct FormatStyle {
   ///      int         aaaa = 12;
   ///      float       b = 23;
   ///      std::string ccc;
   ///
   ///      int         a = 42;
   ///      /* A comment. */
   ///      bool        c = false;
   ///    \endcode
+  /// \version 13
   AlignConsecutiveStyle AlignConsecutiveDeclarations;
 
   /// Different styles for aligning escaped newlines.
   enum EscapedNewlineAlignmentStyle : unsigned char {
     /// Don't align escaped newlines.
     /// \code
     ///   #define A \
     ///     int aaaa; \
enum EscapedNewlineAlignmentStyle : unsigned char {
     ///     int aaaa;                                                                    \
     ///     int b;                                                                       \
     ///     int dddddddddd;
     /// \endcode
     ENAS_Right,
   };
 
   /// Options for aligning backslashes in escaped newlines.
+  /// \version 5
   EscapedNewlineAlignmentStyle AlignEscapedNewlines;
 
   /// Different styles for aligning operands.
   enum OperandAlignmentStyle : unsigned char {
     /// Do not align operands of binary and ternary expressions.
     /// The wrapped lines are indented ``ContinuationIndentWidth`` spaces from
     /// the start of the line.
     OAS_DontAlign,
enum OperandAlignmentStyle : unsigned char {
     ///   int aaa = bbbbbbbbbbbbbbb
     ///           + ccccccccccccccc;
     /// \endcode
     OAS_AlignAfterOperator,
   };
 
   /// If ``true``, horizontally align operands of binary and ternary
   /// expressions.
+  /// \version 12
   OperandAlignmentStyle AlignOperands;
 
   /// If ``true``, aligns trailing comments.
   /// \code
   ///   true:                                   false:
   ///   int a;     // My comment a      vs.     int a; // My comment a
   ///   int b = 2; // comment  b                int b = 2; // comment about b
   /// \endcode
+  /// \version 3.7
   bool AlignTrailingComments;
 
   /// \brief If a function call or braced initializer list doesn't fit on a
   /// line, allow putting all arguments onto the next line, even if
   /// ``BinPackArguments`` is ``false``.
   /// \code
   ///   true:
   ///   callFunction(
   ///       a, b, c, d);
   ///
   ///   false:
   ///   callFunction(a,
   ///                b,
   ///                c,
   ///                d);
   /// \endcode
+  /// \version 9
   bool AllowAllArgumentsOnNextLine;
 
   /// This option is **deprecated**. See ``NextLine`` of
   /// ``PackConstructorInitializers``.
+  /// \version 9
   bool AllowAllConstructorInitializersOnNextLine;
 
   /// If the function declaration doesn't fit on a line,
   /// allow putting all parameters of a function declaration onto
   /// the next line even if ``BinPackParameters`` is ``false``.
   /// \code
   ///   true:
   ///   void myFunction(
   ///       int a, int b, int c, int d, int e);
   ///
   ///   false:
   ///   void myFunction(int a,
   ///                   int b,
   ///                   int c,
   ///                   int d,
   ///                   int e);
   /// \endcode
+  /// \version 3.3
   bool AllowAllParametersOfDeclarationOnNextLine;
 
   /// Allow short enums on a single line.
   /// \code
   ///   true:
   ///   enum { A, B } myEnum;
   ///
   ///   false:
   ///   enum {
   ///     A,
   ///     B
   ///   } myEnum;
   /// \endcode
+  /// \version 12
   bool AllowShortEnumsOnASingleLine;
 
   /// Different styles for merging short blocks containing at most one
   /// statement.
   enum ShortBlockStyle : unsigned char {
     /// Never merge blocks into a single line.
     /// \code
     ///   while (true) {
enum ShortBlockStyle : unsigned char {
     ///   while (true) {}
     ///   while (true) { continue; }
     /// \endcode
     SBS_Always,
   };
 
   /// Dependent on the value, ``while (true) { continue; }`` can be put on a
   /// single line.
+  /// \version 11
   ShortBlockStyle AllowShortBlocksOnASingleLine;
 
   /// If ``true``, short case labels will be contracted to a single line.
   /// \code
   ///   true:                                   false:
   ///   switch (a) {                    vs.     switch (a) {
   ///   case 1: x = 1; break;                   case 1:
   ///   case 2: return;                           x = 1;
   ///   }                                         break;
   ///                                           case 2:
   ///                                             return;
   ///                                           }
   /// \endcode
+  /// \version 3.6
   bool AllowShortCaseLabelsOnASingleLine;
 
   /// Different styles for merging short functions containing at most one
   /// statement.
   enum ShortFunctionStyle : unsigned char {
     /// Never merge functions into a single line.
     SFS_None,
     /// Only merge functions defined inside a class. Same as "inline",
enum ShortFunctionStyle : unsigned char {
     ///   };
     ///   void f() { bar(); }
     /// \endcode
     SFS_All,
   };
 
   /// Dependent on the value, ``int f() { return 0; }`` can be put on a
   /// single line.
+  /// \version 3.5
   ShortFunctionStyle AllowShortFunctionsOnASingleLine;
 
   /// Different styles for handling short if statements.
   enum ShortIfStyle : unsigned char {
     /// Never put short ifs on the same line.
     /// \code
     ///   if (a)
     ///     return;
enum ShortIfStyle : unsigned char {
     ///   else {
     ///     return;
     ///   }
     /// \endcode
     SIS_AllIfsAndElse,
   };
 
   /// Dependent on the value, ``if (a) return;`` can be put on a single line.
+  /// \version 9
   ShortIfStyle AllowShortIfStatementsOnASingleLine;
 
   /// Different styles for merging short lambdas containing at most one
   /// statement.
   enum ShortLambdaStyle : unsigned char {
     /// Never merge lambdas into a single line.
     SLS_None,
     /// Only merge empty lambdas.
enum ShortLambdaStyle : unsigned char {
     ///   auto lambda = [](int a) {}
     ///   auto lambda2 = [](int a) { return a; };
     /// \endcode
     SLS_All,
   };
 
   /// Dependent on the value, ``auto lambda []() { return 0; }`` can be put on a
   /// single line.
+  /// \version 9
   ShortLambdaStyle AllowShortLambdasOnASingleLine;
 
   /// If ``true``, ``while (true) continue;`` can be put on a single
   /// line.
+  /// \version 3.7
   bool AllowShortLoopsOnASingleLine;
 
   /// Different ways to break after the function definition return type.
   /// This option is **deprecated** and is retained for backwards compatibility.
   enum DefinitionReturnTypeBreakingStyle : unsigned char {
     /// Break after return type automatically.
     /// ``PenaltyReturnTypeOnItsOwnLine`` is taken into account.
     DRTBS_None,
enum ReturnTypeBreakingStyle : unsigned char {
     ///     return 1;
     ///   }
     /// \endcode
     RTBS_TopLevelDefinitions,
   };
 
   /// The function definition return type breaking style to use.  This
   /// option is **deprecated** and is retained for backwards compatibility.
+  /// \version 3.7
   DefinitionReturnTypeBreakingStyle AlwaysBreakAfterDefinitionReturnType;
 
   /// The function declaration return type breaking style to use.
+  /// \version 3.8
   ReturnTypeBreakingStyle AlwaysBreakAfterReturnType;
 
   /// If ``true``, always break before multiline string literals.
   ///
   /// This flag is mean to make cases where there are multiple multiline strings
   /// in a file look more consistent. Thus, it will only take effect if wrapping
   /// the string at that point leads to it being indented
   /// ``ContinuationIndentWidth`` spaces from the start of the line.
   /// \code
   ///    true:                                  false:
   ///    aaaa =                         vs.     aaaa = "bbbb"
   ///        "bbbb"                                    "cccc";
   ///        "cccc";
   /// \endcode
+  /// \version 3.4
   bool AlwaysBreakBeforeMultilineStrings;
 
   /// Different ways to break after the template declaration.
   enum BreakTemplateDeclarationsStyle : unsigned char {
     /// Do not force break before declaration.
     /// ``PenaltyBreakTemplateDeclaration`` is taken into account.
     /// \code
     ///    template <typename T> T foo() {
enum BreakTemplateDeclarationsStyle : unsigned char {
     ///    T foo(int aaaaaaaaaaaaaaaaaaaaa,
     ///          int bbbbbbbbbbbbbbbbbbbbb) {
     ///    }
     /// \endcode
     BTDS_Yes
   };
 
   /// The template declaration breaking style to use.
+  /// \version 7
   BreakTemplateDeclarationsStyle AlwaysBreakTemplateDeclarations;
 
   /// A vector of strings that should be interpreted as attributes/qualifiers
   /// instead of identifiers. This can be useful for language extensions or
   /// static analyzer annotations.
   ///
   /// For example:
   /// \code
   ///   x = (char *__capability)&y;
   ///   int function(void) __ununsed;
   ///   void only_writes_to_buffer(char *__output buffer);
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   AttributeMacros: ['__capability', '__output', '__ununsed']
   /// \endcode
   ///
+  /// \version 13
   std::vector<std::string> AttributeMacros;
 
   /// If ``false``, a function call's arguments will either be all on the
   /// same line or will have one line each.
   /// \code
   ///   true:
   ///   void f() {
   ///     f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
   ///   }
   ///
   ///   false:
   ///   void f() {
   ///     f(aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaa,
   ///       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);
   ///   }
   /// \endcode
+  /// \version 3.7
   bool BinPackArguments;
 
   /// The style of inserting trailing commas into container literals.
   enum TrailingCommaStyle : unsigned char {
     /// Do not insert trailing commas.
     TCS_None,
     /// Insert trailing commas in container literals that were wrapped over
     /// multiple lines. Note that this is conceptually incompatible with
struct FormatStyle {
   ///   TSC_Wrapped:
   ///   const someArray = [
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   aaaaaaaaaaaaaaaaaaaaaaaaaa,
   ///   //                        ^ inserted
   ///   ]
   /// \endcode
+  /// \version 12
   TrailingCommaStyle InsertTrailingCommas;
 
   /// If ``false``, a function declaration's or function definition's
   /// parameters will either all be on the same line or will have one line each.
   /// \code
   ///   true:
   ///   void f(int aaaaaaaaaaaaaaaaaaaa, int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   ///
   ///   false:
   ///   void f(int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaa,
   ///          int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
   /// \endcode
+  /// \version 3.7
   bool BinPackParameters;
 
   /// The style of wrapping parameters on the same line (bin-packed) or
   /// on one line each.
   enum BinPackStyle : unsigned char {
     /// Automatically determine parameter bin-packing behavior.
     BPS_Auto,
     /// Always bin-pack parameters.
enum BinaryOperatorStyle : unsigned char {
     ///                     == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
     ///                 && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
     ///                        > ccccccccccccccccccccccccccccccccccccccccc;
     /// \endcode
     BOS_All,
   };
 
   /// The way to wrap binary operators.
+  /// \version 3.6
   BinaryOperatorStyle BreakBeforeBinaryOperators;
 
   /// Different ways to attach braces to their surrounding context.
   enum BraceBreakingStyle : unsigned char {
     /// Always attach braces to surrounding context.
     /// \code
     ///   namespace N {
     ///   enum E {
enum BraceBreakingStyle : unsigned char {
     ///   } // namespace N
     /// \endcode
     BS_WebKit,
     /// Configure each individual brace in `BraceWrapping`.
     BS_Custom
   };
 
   /// The brace breaking style to use.
+  /// \version 3.7
   BraceBreakingStyle BreakBeforeBraces;
 
   /// Different ways to wrap braces after control statements.
   enum BraceWrappingAfterControlStatementStyle : unsigned char {
     /// Never wrap braces after a control statement.
     /// \code
     ///   if (foo()) {
     ///   } else {

   /// \code{.yaml}
   ///   # Example of usage:
   ///   BreakBeforeBraces: Custom
   ///   BraceWrapping:
   ///     AfterEnum: true
   ///     AfterStruct: false
   ///     SplitEmptyFunction: false
   /// \endcode
+  /// \version 3.8
   BraceWrappingFlags BraceWrapping;
 
   /// If ``true``, concept will be placed on a new line.
   /// \code
   ///   true:
   ///    template<typename T>
   ///    concept ...
   ///
   ///   false:
   ///    template<typename T> concept ...
   /// \endcode
+  /// \version 13
   bool BreakBeforeConceptDeclarations;
 
   /// If ``true``, ternary operators will be placed after line breaks.
   /// \code
   ///    true:
   ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription
   ///        ? firstValue
   ///        : SecondValueVeryVeryVeryVeryLong;
   ///
   ///    false:
   ///    veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongDescription ?
   ///        firstValue :
   ///        SecondValueVeryVeryVeryVeryLong;
   /// \endcode
+  /// \version 3.7
   bool BreakBeforeTernaryOperators;
 
   /// Different ways to break initializers.
   enum BreakConstructorInitializersStyle : unsigned char {
     /// Break constructor initializers before the colon and after the commas.
     /// \code
     ///    Constructor()
     ///        : initializer1(),
enum BreakConstructorInitializersStyle : unsigned char {
     ///    Constructor() :
     ///        initializer1(),
     ///        initializer2()
     /// \endcode
     BCIS_AfterColon
   };
 
   /// The break constructor initializers style to use.
+  /// \version 5
   BreakConstructorInitializersStyle BreakConstructorInitializers;
 
   /// Break after each annotation on a field in Java files.
   /// \code{.java}
   ///    true:                                  false:
   ///    @Partial                       vs.     @Partial @Mock DataLoad loader;
   ///    @Mock
   ///    DataLoad loader;
   /// \endcode
+  /// \version 3.8
   bool BreakAfterJavaFieldAnnotations;
 
   /// Allow breaking string literals when formatting.
   /// \code
   ///    true:
   ///    const char* x = "veryVeryVeryVeryVeryVe"
   ///                    "ryVeryVeryVeryVeryVery"
   ///                    "VeryLongString";
   ///
   ///    false:
   ///    const char* x =
   ///      "veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongString";
   /// \endcode
+  /// \version 3.9
   bool BreakStringLiterals;
 
   /// The column limit.
   ///
   /// A column limit of ``0`` means that there is no column limit. In this case,
   /// clang-format will respect the input's line breaking decisions within
   /// statements unless they contradict other rules.
+  /// \version 3.7
   unsigned ColumnLimit;
 
   /// A regular expression that describes comments with special meaning,
   /// which should not be split into lines or otherwise changed.
   /// \code
   ///    // CommentPragmas: '^ FOOBAR pragma:'
   ///    // Will leave the following line unaffected
   ///    #include <vector> // FOOBAR pragma: keep
   /// \endcode
+  /// \version 3.7
   std::string CommentPragmas;
 
   /// Different const/volatile qualifier alignment styles.
   enum QualifierAlignmentStyle {
     /// Don't change specifiers/qualifier to either Left or Right alignment
     /// (default)
     /// \code
     ///    int const a;
enum QualifierAlignmentStyle {
     /// \endcode
     QAS_Custom
   };
 
   /// Different ways to arrange const/volatile qualifiers.
   /// \warning
   ///  ``QualifierAlignment`` COULD lead to incorrect code generation.
   /// \endwarning
+  /// \version 14
   QualifierAlignmentStyle QualifierAlignment;
 
   /// The Order in which the qualifiers appear.
   /// Order is a an array can contain any of the following
   ///
   ///   * const
   ///   * inline
   ///   * static
   ///   * constexpr
   ///   * volatile
   ///   * restrict
   ///   * type
   ///
   /// Note: it MUST contain 'type'.
   /// Items to the left of type will be aligned in the order supplied.
   /// Items to the right of type will be aligned  in the order supplied.
   ///
   /// \code{.yaml}
   ///   QualifierOrder: ['inline', 'static', 'type', 'const', 'volatile' ]
   /// \endcode
+  /// \version 14
   std::vector<std::string> QualifierOrder;
 
   /// Different ways to break inheritance list.
   enum BreakInheritanceListStyle : unsigned char {
     /// Break inheritance list before the colon and after the commas.
     /// \code
     ///    class Foo
     ///        : Base1,
enum BreakInheritanceListStyle : unsigned char {
     ///    class Foo : Base1,
     ///                Base2
     ///    {};
     /// \endcode
     BILS_AfterComma,
   };
 
   /// The inheritance list style to use.
+  /// \version 7
   BreakInheritanceListStyle BreakInheritanceList;
 
   /// If ``true``, consecutive namespace declarations will be on the same
   /// line. If ``false``, each namespace is declared on a new line.
   /// \code
   ///   true:
   ///   namespace Foo { namespace Bar {
   ///   }}
   ///
   ///   false:
   ///   namespace Foo {
   ///   namespace Bar {
   ///   }
   ///   }
   /// \endcode
   ///
   /// If it does not fit on a single line, the overflowing namespaces get
   /// wrapped:
   /// \code
   ///   namespace Foo { namespace Bar {
   ///   namespace Extra {
   ///   }}}
   /// \endcode
+  /// \version 5
   bool CompactNamespaces;
 
   /// This option is **deprecated**. See ``CurrentLine`` of
   /// ``PackConstructorInitializers``.
+  /// \version 3.7
   bool ConstructorInitializerAllOnOneLineOrOnePerLine;
 
   /// The number of characters to use for indentation of constructor
   /// initializer lists as well as inheritance lists.
+  /// \version 3.7
   unsigned ConstructorInitializerIndentWidth;
 
   /// Indent width for line continuations.
   /// \code
   ///    ContinuationIndentWidth: 2
   ///
   ///    int i =         //  VeryVeryVeryVeryVeryLongComment
   ///      longFunction( // Again a long comment
   ///        arg);
   /// \endcode
+  /// \version 3.7
   unsigned ContinuationIndentWidth;
 
   /// If ``true``, format braced lists as best suited for C++11 braced
   /// lists.
   ///
   /// Important differences:
   /// - No spaces inside the braced list.
   /// - No line break before the closing brace.
   /// - Indentation with the continuation indent, not with the block indent.
   ///
   /// Fundamentally, C++11 braced lists are formatted exactly like function
   /// calls would be formatted in their place. If the braced list follows a name
   /// (e.g. a type or variable name), clang-format formats as if the ``{}`` were
   /// the parentheses of a function call with that name. If there is no name,
   /// a zero-length name is assumed.
   /// \code
   ///    true:                                  false:
   ///    vector<int> x{1, 2, 3, 4};     vs.     vector<int> x{ 1, 2, 3, 4 };
   ///    vector<T> x{{}, {}, {}, {}};           vector<T> x{ {}, {}, {}, {} };
   ///    f(MyMap[{composite, key}]);            f(MyMap[{ composite, key }]);
   ///    new int[3]{1, 2, 3};                   new int[3]{ 1, 2, 3 };
   /// \endcode
+  /// \version 3.4
   bool Cpp11BracedListStyle;
 
   /// \brief Analyze the formatted file for the most used line ending (``\r\n``
   /// or ``\n``). ``UseCRLF`` is only used as a fallback if none can be derived.
+  /// \version 11
   bool DeriveLineEnding;
 
   /// If ``true``, analyze the formatted file for the most common
   /// alignment of ``&`` and ``*``.
   /// Pointer and reference alignment styles are going to be updated according
   /// to the preferences found in the file.
   /// ``PointerAlignment`` is then used only as fallback.
+  /// \version 3.7
   bool DerivePointerAlignment;
 
   /// Disables formatting completely.
+  /// \version 3.7
   bool DisableFormat;
 
   /// Different styles for empty line after access modifiers.
   /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
   /// empty lines between two access modifiers.
   enum EmptyLineAfterAccessModifierStyle : unsigned char {
     /// Remove all empty lines after access modifiers.
     /// \code
enum EmptyLineAfterAccessModifierStyle : unsigned char {
     ///   };
     /// \endcode
     ELAAMS_Always,
   };
 
   /// Defines when to put an empty line after access modifiers.
   /// ``EmptyLineBeforeAccessModifier`` configuration handles the number of
   /// empty lines between two access modifiers.
+  /// \version 14
   EmptyLineAfterAccessModifierStyle EmptyLineAfterAccessModifier;
 
   /// Different styles for empty line before access modifiers.
   enum EmptyLineBeforeAccessModifierStyle : unsigned char {
     /// Remove all empty lines before access modifiers.
     /// \code
     ///   struct foo {
     ///   private:
enum EmptyLineBeforeAccessModifierStyle : unsigned char {
     ///
     ///   protected:
     ///   };
     /// \endcode
     ELBAMS_Always,
   };
 
   /// Defines in which cases to put empty line before access modifiers.
+  /// \version 13
   EmptyLineBeforeAccessModifierStyle EmptyLineBeforeAccessModifier;
 
   /// If ``true``, clang-format detects whether function calls and
   /// definitions are formatted with one parameter per line.
   ///
   /// Each call can be bin-packed, one-per-line or inconclusive. If it is
   /// inconclusive, e.g. completely on one line, but a decision needs to be
   /// made, clang-format analyzes whether there are other bin-packed cases in
   /// the input file and act accordingly.
   ///
   /// NOTE: This is an experimental flag, that might go away or be renamed. Do
   /// not use this in config files, etc. Use at your own risk.
+  /// \version 3.7
   bool ExperimentalAutoDetectBinPacking;
 
   /// Different ways to try to fit all constructor initializers on a line.
   enum PackConstructorInitializersStyle : unsigned char {
     /// Always put each constructor initializer on its own line.
     /// \code
     ///    Constructor()
     ///        : a(),
enum PackConstructorInitializersStyle : unsigned char {
     ///        : aaaaaaaaaaaaaaaaaaaa(),
     ///          bbbbbbbbbbbbbbbbbbbb(),
     ///          cccccccccccccccccccc()
     /// \endcode
     PCIS_NextLine,
   };
 
   /// The pack constructor initializers style to use.
+  /// \version 14;
   PackConstructorInitializersStyle PackConstructorInitializers;
 
   /// If ``true``, clang-format adds missing namespace end comments for
   /// short namespaces and fixes invalid existing ones. Short ones are
   /// controlled by "ShortNamespaceLines".
   /// \code
   ///    true:                                  false:
   ///    namespace a {                  vs.     namespace a {
   ///    foo();                                 foo();
   ///    bar();                                 bar();
   ///    } // namespace a                       }
   /// \endcode
+  /// \version 5
   bool FixNamespaceComments;
 
   /// A vector of macros that should be interpreted as foreach loops
   /// instead of as function calls.
   ///
   /// These are expected to be macros of the form:
   /// \code
   ///   FOREACH(<variable-declaration>, ...)
   ///     <loop-body>
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   ForEachMacros: ['RANGES_FOR', 'FOREACH']
   /// \endcode
   ///
   /// For example: BOOST_FOREACH.
+  /// \version 3.7
   std::vector<std::string> ForEachMacros;
 
   /// A vector of macros that should be interpreted as conditionals
   /// instead of as function calls.
   ///
   /// These are expected to be macros of the form:
   /// \code
   ///   IF(...)
   ///     <conditional-body>
   ///   else IF(...)
   ///     <conditional-body>
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   IfMacros: ['IF']
   /// \endcode
   ///
   /// For example: `KJ_IF_MAYBE
   /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/tour.md#maybes>`_
+  /// \version 14
   std::vector<std::string> IfMacros;
 
   /// \brief A vector of macros that should be interpreted as type declarations
   /// instead of as function calls.
   ///
   /// These are expected to be macros of the form:
   /// \code
   ///   STACK_OF(...)
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   TypenameMacros: ['STACK_OF', 'LIST']
   /// \endcode
   ///
   /// For example: OpenSSL STACK_OF, BSD LIST_ENTRY.
+  /// \version 9
   std::vector<std::string> TypenameMacros;
 
   /// A vector of macros that should be interpreted as complete
   /// statements.
   ///
   /// Typical macros are expressions, and require a semi-colon to be
   /// added; sometimes this is not the case, and this allows to make
   /// clang-format aware of such cases.
   ///
   /// For example: Q_UNUSED
+  /// \version 8
   std::vector<std::string> StatementMacros;
 
   /// A vector of macros which are used to open namespace blocks.
   ///
   /// These are expected to be macros of the form:
   /// \code
   ///   NAMESPACE(<namespace-name>, ...) {
   ///     <namespace-content>
   ///   }
   /// \endcode
   ///
   /// For example: TESTSUITE
+  /// \version 9
   std::vector<std::string> NamespaceMacros;
 
   /// A vector of macros which are whitespace-sensitive and should not
   /// be touched.
   ///
   /// These are expected to be macros of the form:
   /// \code
   ///   STRINGIZE(...)
   /// \endcode
   ///
   /// In the .clang-format configuration file, this can be configured like:
   /// \code{.yaml}
   ///   WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE']
   /// \endcode
   ///
   /// For example: BOOST_PP_STRINGIZE
+  /// \version 12
   std::vector<std::string> WhitespaceSensitiveMacros;
 
   tooling::IncludeStyle IncludeStyle;
 
   /// Specify whether access modifiers should have their own indentation level.
   ///
   /// When ``false``, access modifiers are indented (or outdented) relative to
   /// the record members, respecting the ``AccessModifierOffset``. Record

   ///      };                                       };
   ///    public:                                  public:
   ///      C();                                     C();
   ///    };                                     };
   ///    void foo() {                           void foo() {
   ///      return 1;                              return 1;
   ///    }                                      }
   /// \endcode
+  /// \version 13
   bool IndentAccessModifiers;
 
   /// Indent case labels one level from the switch statement.
   ///
   /// When ``false``, use the same indentation level as for the switch
   /// statement. Switch statement body is always indented one level more than
   /// case labels (except the first block following the case label, which
   /// itself indents the code - unless IndentCaseBlocks is enabled).
   /// \code
   ///    false:                                 true:
   ///    switch (fool) {                vs.     switch (fool) {
   ///    case 1:                                  case 1:
   ///      bar();                                   bar();
   ///      break;                                   break;
   ///    default:                                 default:
   ///      plop();                                  plop();
   ///    }                                      }
   /// \endcode
+  /// \version 3.3
   bool IndentCaseLabels;
 
   /// Indent case label blocks one level from the case label.
   ///
   /// When ``false``, the block following the case label uses the same
   /// indentation level as for the case label, treating the case label the same
   /// as an if-statement.
   /// When ``true``, the block gets indented as a scope block.
   /// \code
   ///    false:                                 true:
   ///    switch (fool) {                vs.     switch (fool) {
   ///    case 1: {                              case 1:
   ///      bar();                                 {
   ///    } break;                                   bar();
   ///    default: {                               }
   ///      plop();                                break;
   ///    }                                      default:
   ///    }                                        {
   ///                                               plop();
   ///                                             }
   ///                                           }
   /// \endcode
+  /// \version 11
   bool IndentCaseBlocks;
 
   /// Indent goto labels.
   ///
   /// When ``false``, goto labels are flushed left.
   /// \code
   ///    true:                                  false:
   ///    int f() {                      vs.     int f() {
   ///      if (foo()) {                           if (foo()) {
   ///      label1:                              label1:
   ///        bar();                                 bar();
   ///      }                                      }
   ///    label2:                                label2:
   ///      return 1;                              return 1;
   ///    }                                      }
   /// \endcode
+  /// \version 10
   bool IndentGotoLabels;
 
   /// Options for indenting preprocessor directives.
   enum PPDirectiveIndentStyle : unsigned char {
     /// Does not indent any directives.
     /// \code
     ///    #if FOO
     ///    #if BAR
enum PPDirectiveIndentStyle : unsigned char {
     ///        #include <foo>
     ///      #endif
     ///    #endif
     /// \endcode
     PPDIS_BeforeHash
   };
 
   /// The preprocessor directive indenting style to use.
+  /// \version 6
   PPDirectiveIndentStyle IndentPPDirectives;
 
   /// Indents extern blocks
   enum IndentExternBlockStyle : unsigned char {
     /// Backwards compatible with AfterExternBlock's indenting.
     /// \code
     ///    IndentExternBlock: AfterExternBlock
     ///    BraceWrapping.AfterExternBlock: true
enum IndentExternBlockStyle : unsigned char {
     ///     extern "C" {
     ///       void foo();
     ///     }
     /// \endcode
     IEBS_Indent,
   };
 
   /// IndentExternBlockStyle is the type of indenting of extern blocks.
+  /// \version 12
   IndentExternBlockStyle IndentExternBlock;
 
   /// Indent the requires clause in a template
   /// \code
   ///    true:
   ///    template <typename It>
   ///      requires Iterator<It>
   ///    void sort(It begin, It end) {
   ///      //....
   ///    }
   ///
   ///    false:
   ///    template <typename It>
   ///    requires Iterator<It>
   ///    void sort(It begin, It end) {
   ///      //....
   ///    }
   /// \endcode
+  /// \version 13
   bool IndentRequires;
 
   /// The number of columns to use for indentation.
   /// \code
   ///    IndentWidth: 3
   ///
   ///    void f() {
   ///       someFunction();
   ///       if (true, false) {
   ///          f();
   ///       }
   ///    }
   /// \endcode
+  /// \version 3.7
   unsigned IndentWidth;
 
   /// Indent if a function definition or declaration is wrapped after the
   /// type.
   /// \code
   ///    true:
   ///    LoooooooooooooooooooooooooooooooooooooooongReturnType
   ///        LoooooooooooooooooooooooooooooooongFunctionDeclaration();
   ///
   ///    false:
   ///    LoooooooooooooooooooooooooooooooooooooooongReturnType
   ///    LoooooooooooooooooooooooooooooooongFunctionDeclaration();
   /// \endcode
+  /// \version 3.7
   bool IndentWrappedFunctionNames;
 
   /// A vector of prefixes ordered by the desired groups for Java imports.
   ///
   /// One group's prefix can be a subset of another - the longest prefix is
   /// always matched. Within a group, the imports are ordered lexicographically.
   /// Static imports are grouped separately and follow the same group rules.
   /// By default, static imports are placed before non-static imports,

   ///    import com.example.ClassA;
   ///    import com.example.Test;
   ///    import com.example.a.ClassB;
   ///
   ///    import com.test.ClassC;
   ///
   ///    import org.example.ClassD;
   /// \endcode
+  /// \version 8
   std::vector<std::string> JavaImportGroups;
 
   /// Quotation styles for JavaScript strings. Does not affect template
   /// strings.
   enum JavaScriptQuoteStyle : unsigned char {
     /// Leave string quotes as they are.
     /// \code{.js}
     ///    string1 = "foo";
enum JavaScriptQuoteStyle : unsigned char {
     /// \code{.js}
     ///    string1 = "foo";
     ///    string2 = "bar";
     /// \endcode
     JSQS_Double
   };
 
   /// The JavaScriptQuoteStyle to use for JavaScript strings.
+  /// \version 3.9
   JavaScriptQuoteStyle JavaScriptQuotes;
 
   // clang-format off
   /// Whether to wrap JavaScript import/export statements.
   /// \code{.js}
   ///    true:
   ///    import {
   ///        VeryLongImportsAreAnnoying,
   ///        VeryLongImportsAreAnnoying,
   ///        VeryLongImportsAreAnnoying,
   ///    } from 'some/module.js'
   ///
   ///    false:
   ///    import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,} from "some/module.js"
   /// \endcode
+  /// \version 3.9
   bool JavaScriptWrapImports;
   // clang-format on
 
   /// If true, the empty line at the start of blocks is kept.
   /// \code
   ///    true:                                  false:
   ///    if (foo) {                     vs.     if (foo) {
   ///                                             bar();
   ///      bar();                               }
   ///    }
   /// \endcode
+  /// \version 3.7
   bool KeepEmptyLinesAtTheStartOfBlocks;
 
   /// Supported languages.
   ///
   /// When stored in a configuration file, specifies the language, that the
   /// configuration targets. When passed to the ``reformat()`` function, enables
   /// syntax features specific to the language.
   enum LanguageKind : unsigned char {
enum LanguageKind : unsigned char {
     /// (https://developers.google.com/protocol-buffers/).
     LK_TextProto
   };
   bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
   bool isCSharp() const { return Language == LK_CSharp; }
   bool isJson() const { return Language == LK_Json; }
 
   /// Language, this format style is targeted at.
+  /// \version 3.5
   LanguageKind Language;
 
   /// Indentation logic for lambda bodies.
   enum LambdaBodyIndentationKind : unsigned char {
     /// Align lambda body relative to the lambda signature. This is the default.
     /// \code
     ///    someMethod(
     ///        [](SomeReallyLongLambdaSignatureArgument foo) {

   /// causes the lambda body to be indented one additional level relative to
   /// the indentation level of the signature. ``OuterScope`` forces the lambda
   /// body to be indented one additional level relative to the parent scope
   /// containing the lambda signature. For callback-heavy code, it may improve
   /// readability to have the signature indented two levels and to use
   /// ``OuterScope``. The KJ style guide requires ``OuterScope``.
   /// `KJ style guide
   /// <https://github.com/capnproto/capnproto/blob/master/kjdoc/style-guide.md>`_
+  /// \version 13
   LambdaBodyIndentationKind LambdaBodyIndentation;
 
   /// A regular expression matching macros that start a block.
   /// \code
   ///    # With:
   ///    MacroBlockBegin: "^NS_MAP_BEGIN|\
-  ///    NS_TABLE_HEAD$"
   ///    MacroBlockEnd: "^\
-  ///    NS_MAP_END|\
-  ///    NS_TABLE_.*_END$"
   ///
   ///    NS_MAP_BEGIN
   ///      foo();
   ///    NS_MAP_END
   ///
   ///    NS_TABLE_HEAD
   ///      bar();
   ///    NS_TABLE_FOO_END
   ///
   ///    # Without:
   ///    NS_MAP_BEGIN
   ///    foo();
   ///    NS_MAP_END
   ///
   ///    NS_TABLE_HEAD
   ///    bar();
   ///    NS_TABLE_FOO_END
   /// \endcode
+  /// \version 3.7
   std::string MacroBlockBegin;
 
   /// A regular expression matching macros that end a block.
+  /// \version 3.7
   std::string MacroBlockEnd;
 
   /// The maximum number of consecutive empty lines to keep.
   /// \code
   ///    MaxEmptyLinesToKeep: 1         vs.     MaxEmptyLinesToKeep: 0
   ///    int f() {                              int f() {
   ///      int = 1;                                 int i = 1;
   ///                                               i = foo();
   ///      i = foo();                               return i;
   ///                                           }
   ///      return i;
   ///    }
   /// \endcode
+  /// \version 3.7
   unsigned MaxEmptyLinesToKeep;
 
   /// Different ways to indent namespace contents.
   enum NamespaceIndentationKind : unsigned char {
     /// Don't indent in namespaces.
     /// \code
     ///    namespace out {
     ///    int i;
enum NamespaceIndentationKind : unsigned char {
     ///        int i;
     ///      }
     ///    }
     /// \endcode
     NI_All
   };
 
   /// The indentation used for namespaces.
+  /// \version 3.7
   NamespaceIndentationKind NamespaceIndentation;
 
   /// Controls bin-packing Objective-C protocol conformance list
   /// items into as few lines as possible when they go over ``ColumnLimit``.
   ///
   /// If ``Auto`` (the default), delegates to the value in
   /// ``BinPackParameters``. If that is ``true``, bin-packs Objective-C
   /// protocol conformance list items into as few lines as possible
///    NS_TABLE_.*_END$"
   ///    Never (or Auto, if BinPackParameters=false):
   ///    @interface ddddddddddddd () <
   ///        ddddddddddddd,
   ///        ddddddddddddd,
   ///        ddddddddddddd,
   ///        ddddddddddddd> {
   ///    }
   /// \endcode
+  /// \version 7
   BinPackStyle ObjCBinPackProtocolList;
 
   /// The number of characters to use for indentation of ObjC blocks.
   /// \code{.objc}
   ///    ObjCBlockIndentWidth: 4
   ///
   ///    [operation setCompletionBlock:^{
   ///        [self onOperationDone];
   ///    }];
   /// \endcode
+  /// \version 3.7
   unsigned ObjCBlockIndentWidth;
 
   /// Add a space after ``@property`` in Objective-C, i.e. use
   /// ``@property (readonly)`` instead of ``@property(readonly)``.
+  /// \version 3.7
   bool ObjCSpaceAfterProperty;
 
   /// Break parameters list into lines when there is nested block
   /// parameters in a function call.
   /// \code
   ///   false:
   ///    - (void)_aMethod
   ///    {
   ///        [self.test1 t:self w:self callback:^(typeof(self) self, NSNumber
   ///        *u, NSNumber *v) {
   ///            u = c;
   ///        }]
   ///    }
   ///    true:
   ///    - (void)_aMethod
   ///    {
   ///       [self.test1 t:self
   ///                    w:self
   ///           callback:^(typeof(self) self, NSNumber *u, NSNumber *v) {
   ///                u = c;
   ///            }]
   ///    }
   /// \endcode
+  /// \version 12
   bool ObjCBreakBeforeNestedBlockParam;
 
   /// Add a space in front of an Objective-C protocol list, i.e. use
   /// ``Foo <Protocol>`` instead of ``Foo<Protocol>``.
+  /// \version 3.7
   bool ObjCSpaceBeforeProtocolList;
 
   /// The penalty for breaking around an assignment operator.
+  /// \version 5
   unsigned PenaltyBreakAssignment;
 
   /// The penalty for breaking a function call after ``call(``.
+  /// \version 3.7
   unsigned PenaltyBreakBeforeFirstCallParameter;
 
   /// The penalty for each line break introduced inside a comment.
+  /// \version 3.7
   unsigned PenaltyBreakComment;
 
   /// The penalty for breaking before the first ``<<``.
+  /// \version 3.7
   unsigned PenaltyBreakFirstLessLess;
 
   /// The penalty for each line break introduced inside a string literal.
+  /// \version 3.7
   unsigned PenaltyBreakString;
 
   /// The penalty for breaking after template declaration.
+  /// \version 7
   unsigned PenaltyBreakTemplateDeclaration;
 
   /// The penalty for each character outside of the column limit.
+  /// \version 3.7
   unsigned PenaltyExcessCharacter;
 
   /// Penalty for putting the return type of a function onto its own
   /// line.
+  /// \version 3.7
   unsigned PenaltyReturnTypeOnItsOwnLine;
 
   /// Penalty for each character of whitespace indentation
   /// (counted relative to leading non-whitespace column).
+  /// \version 13
   unsigned PenaltyIndentedWhitespace;
 
   /// The ``&``, ``&&`` and ``*`` alignment style.
   enum PointerAlignmentStyle : unsigned char {
     /// Align pointer to the left.
     /// \code
     ///   int* a;
     /// \endcode
     PAS_Left,
     /// Align pointer to the right.
     /// \code
     ///   int *a;
     /// \endcode
     PAS_Right,
     /// Align pointer in the middle.
     /// \code
     ///   int * a;
     /// \endcode
     PAS_Middle
   };
 
   /// Pointer and reference alignment style.
+  /// \version 3.7
   PointerAlignmentStyle PointerAlignment;
 
   /// The number of columns to use for indentation of preprocessor statements.
   /// When set to -1 (default) ``IndentWidth`` is used also for preprocessor
   /// statements.
   /// \code
   ///    PPIndentWidth: 1
   ///
   ///    #ifdef __linux__
   ///    # define FOO
   ///    #else
   ///    # define BAR
   ///    #endif
   /// \endcode
+  /// \version 14
   int PPIndentWidth;
 
   /// See documentation of ``RawStringFormats``.
   struct RawStringFormat {
     /// The language of this raw string.
     LanguageKind Language;
     /// A list of raw string delimiters that match this language.
     std::vector<std::string> Delimiters;
///    NS_TABLE_.*_END$"
   ///         BasedOnStyle: google
   ///     - Language: Cpp
   ///         Delimiters:
   ///           - 'cc'
   ///           - 'cpp'
   ///         BasedOnStyle: llvm
   ///         CanonicalDelimiter: 'cc'
   /// \endcode
+  /// \version 6
   std::vector<RawStringFormat> RawStringFormats;
 
   /// \brief The ``&`` and ``&&`` alignment style.
   enum ReferenceAlignmentStyle {
     /// Align reference like ``PointerAlignment``.
     RAS_Pointer,
     /// Align reference to the left.
     /// \code
enum ReferenceAlignmentStyle {
     /// \code
     ///   int & a;
     /// \endcode
     RAS_Middle
   };
 
   /// \brief Reference alignment style (overrides ``PointerAlignment`` for
   /// references).
+  /// \version 14
   ReferenceAlignmentStyle ReferenceAlignment;
 
   // clang-format off
   /// If ``true``, clang-format will attempt to re-flow comments.
   /// \code
   ///    false:
   ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information
   ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of information */
   ///
   ///    true:
   ///    // veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
   ///    // information
   ///    /* second veryVeryVeryVeryVeryVeryVeryVeryVeryVeryVeryLongComment with plenty of
   ///     * information */
   /// \endcode
+  /// \version 4
   bool ReflowComments;
   // clang-format on
 
   /// The maximal number of unwrapped lines that a short namespace spans.
   /// Defaults to 1.
   ///
   /// This determines the maximum length of short namespaces by counting
   /// unwrapped lines (i.e. containing neither opening nor closing
   /// namespace brace) and makes "FixNamespaceComments" omit adding
   /// end comments for those.
   /// \code
   ///    ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
   ///    namespace a {                      namespace a {
   ///      int foo;                           int foo;
   ///    }                                  } // namespace a
   ///
   ///    ShortNamespaceLines: 1     vs.     ShortNamespaceLines: 0
   ///    namespace b {                      namespace b {
   ///      int foo;                           int foo;
   ///      int bar;                           int bar;
   ///    } // namespace b                   } // namespace b
   /// \endcode
+  /// \version 14
   unsigned ShortNamespaceLines;
 
   /// Include sorting options.
   enum SortIncludesOptions : unsigned char {
     /// Includes are never sorted.
     /// \code
     ///    #include "B/A.h"
     ///    #include "A/B.h"
///    NS_TABLE_.*_END$"
   };
 
   /// Controls if and how clang-format will sort ``#includes``.
   /// If ``Never``, includes are never sorted.
   /// If ``CaseInsensitive``, includes are sorted in an ASCIIbetical or case
   /// insensitive fashion.
   /// If ``CaseSensitive``, includes are sorted in an alphabetical or case
   /// sensitive fashion.
+  /// \version 4
   SortIncludesOptions SortIncludes;
 
   /// Position for Java Static imports.
   enum SortJavaStaticImportOptions : unsigned char {
     /// Static imports are placed before non-static imports.
     /// \code{.java}
     ///   import static org.example.function1;
     ///
     ///   import org.example.ClassA;
     /// \endcode
     SJSIO_Before,
     /// Static imports are placed after non-static imports.
     /// \code{.java}
     ///   import org.example.ClassA;
     ///
     ///   import static org.example.function1;
     /// \endcode
     SJSIO_After,
   };
 
   /// When sorting Java imports, by default static imports are placed before
   /// non-static imports. If ``JavaStaticImportAfterImport`` is ``After``,
   /// static imports are placed after non-static imports.
+  /// \version 13
   SortJavaStaticImportOptions SortJavaStaticImport;
 
   /// If ``true``, clang-format will sort using declarations.
   ///
   /// The order of using declarations is defined as follows:
   /// Split the strings by "::" and discard any initial empty strings. The last
   /// element of each list is a non-namespace name; all others are namespace
   /// names. Sort the lists of names lexicographically, where the sort order of
   /// individual names is that all non-namespace names come before all namespace
   /// names, and within those groups, names are in case-insensitive
   /// lexicographic order.
   /// \code
   ///    false:                                 true:
   ///    using std::cout;               vs.     using std::cin;
   ///    using std::cin;                        using std::cout;
   /// \endcode
+  /// \version 5
   bool SortUsingDeclarations;
 
   /// If ``true``, a space is inserted after C style casts.
   /// \code
   ///    true:                                  false:
   ///    (int) i;                       vs.     (int)i;
   /// \endcode
+  /// \version 3.5
   bool SpaceAfterCStyleCast;
 
   /// If ``true``, a space is inserted after the logical not operator (``!``).
   /// \code
   ///    true:                                  false:
   ///    ! someExpression();            vs.     !someExpression();
   /// \endcode
+  /// \version 9
   bool SpaceAfterLogicalNot;
 
   /// If \c true, a space will be inserted after the 'template' keyword.
   /// \code
   ///    true:                                  false:
   ///    template <int> void foo();     vs.     template<int> void foo();
   /// \endcode
+  /// \version 4
   bool SpaceAfterTemplateKeyword;
 
   /// Different ways to put a space before opening parentheses.
   enum SpaceAroundPointerQualifiersStyle : unsigned char {
     /// Don't ensure spaces around pointer qualifiers and use PointerAlignment
     /// instead.
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
enum SpaceAroundPointerQualifiersStyle : unsigned char {
     /// \code
     ///    PointerAlignment: Left                 PointerAlignment: Right
     ///    void* const * x = NULL;         vs.     void * const *x = NULL;
     /// \endcode
     SAPQ_Both,
   };
 
   ///  Defines in which cases to put a space before or after pointer qualifiers
+  /// \version 13
   SpaceAroundPointerQualifiersStyle SpaceAroundPointerQualifiers;
 
   /// If ``false``, spaces will be removed before assignment operators.
   /// \code
   ///    true:                                  false:
   ///    int a = 5;                     vs.     int a= 5;
   ///    a += 42;                               a+= 42;
   /// \endcode
+  /// \version 3.7
   bool SpaceBeforeAssignmentOperators;
 
   /// If ``false``, spaces will be removed before case colon.
   /// \code
   ///   true:                                   false
   ///   switch (x) {                    vs.     switch (x) {
   ///     case 1 : break;                         case 1: break;
   ///   }                                       }
   /// \endcode
+  /// \version 13
   bool SpaceBeforeCaseColon;
 
   /// If ``true``, a space will be inserted before a C++11 braced list
   /// used to initialize an object (after the preceding identifier or type).
   /// \code
   ///    true:                                  false:
   ///    Foo foo { bar };               vs.     Foo foo{ bar };
   ///    Foo {};                                Foo{};
   ///    vector<int> { 1, 2, 3 };               vector<int>{ 1, 2, 3 };
   ///    new int[3] { 1, 2, 3 };                new int[3]{ 1, 2, 3 };
   /// \endcode
+  /// \version 7
   bool SpaceBeforeCpp11BracedList;
 
   /// If ``false``, spaces will be removed before constructor initializer
   /// colon.
   /// \code
   ///    true:                                  false:
   ///    Foo::Foo() : a(a) {}                   Foo::Foo(): a(a) {}
   /// \endcode
+  /// \version 7
   bool SpaceBeforeCtorInitializerColon;
 
   /// If ``false``, spaces will be removed before inheritance colon.
   /// \code
   ///    true:                                  false:
   ///    class Foo : Bar {}             vs.     class Foo: Bar {}
   /// \endcode
+  /// \version 7
   bool SpaceBeforeInheritanceColon;
 
   /// Different ways to put a space before opening parentheses.
   enum SpaceBeforeParensOptions : unsigned char {
     /// Never put a space before opening parentheses.
     /// \code
     ///    void f() {
     ///      if(true) {
enum SpaceBeforeParensOptions : unsigned char {
     ///        f ();
     ///      }
     ///    }
     /// \endcode
     SBPO_Always
   };
 
   /// Defines in which cases to put a space before opening parentheses.
+  /// \version 3.5
   SpaceBeforeParensOptions SpaceBeforeParens;
 
   /// If ``false``, spaces will be removed before range-based for loop
   /// colon.
   /// \code
   ///    true:                                  false:
   ///    for (auto v : values) {}       vs.     for(auto v: values) {}
   /// \endcode
+  /// \version 7
   bool SpaceBeforeRangeBasedForLoopColon;
 
   /// If ``true``, spaces will be inserted into ``{}``.
   /// \code
   ///    true:                                false:
   ///    void f() { }                   vs.   void f() {}
   ///    while (true) { }                     while (true) {}
   /// \endcode
+  /// \version 11
   bool SpaceInEmptyBlock;
 
   /// If ``true``, spaces may be inserted into ``()``.
   /// \code
   ///    true:                                false:
   ///    void f( ) {                    vs.   void f() {
   ///      int x[] = {foo( ), bar( )};          int x[] = {foo(), bar()};
   ///      if (true) {                          if (true) {
   ///        f( );                                f();
   ///      }                                    }
   ///    }                                    }
   /// \endcode
+  /// \version 3.7
   bool SpaceInEmptyParentheses;
 
   /// The number of spaces before trailing line comments
   /// (``//`` - comments).
   ///
   /// This does not affect trailing block comments (``/*`` - comments) as
   /// those commonly have different usage patterns and a number of special
   /// cases.
   /// \code
   ///    SpacesBeforeTrailingComments: 3
   ///    void f() {
   ///      if (true) {   // foo1
   ///        f();        // bar
   ///      }             // foo
   ///    }
   /// \endcode
+  /// \version 3.7
   unsigned SpacesBeforeTrailingComments;
 
   /// Styles for adding spacing after ``<`` and before ``>`
   ///  in template argument lists.
   enum SpacesInAnglesStyle : unsigned char {
     /// Remove spaces after ``<`` and before ``>``.
     /// \code
     ///    static_cast<int>(arg);
     ///    std::function<void(int)> fct;
     /// \endcode
     SIAS_Never,
     /// Add spaces after ``<`` and before ``>``.
     /// \code
     ///    static_cast< int >(arg);
     ///    std::function< void(int) > fct;
     /// \endcode
     SIAS_Always,
     /// Keep a single space after ``<`` and before ``>`` if any spaces were
     /// present. Option ``Standard: Cpp03`` takes precedence.
     SIAS_Leave
   };
   /// The SpacesInAnglesStyle to use for template argument lists.
+  /// \version 14
   SpacesInAnglesStyle SpacesInAngles;
 
   /// If ``true``, spaces will be inserted around if/for/switch/while
   /// conditions.
   /// \code
   ///    true:                                  false:
   ///    if ( a )  { ... }              vs.     if (a) { ... }
   ///    while ( i < 5 )  { ... }               while (i < 5) { ... }
   /// \endcode
+  /// \version 11
   bool SpacesInConditionalStatement;
 
   /// If ``true``, spaces are inserted inside container literals (e.g.
   /// ObjC and Javascript array and dict literals).
   /// \code{.js}
   ///    true:                                  false:
   ///    var arr = [ 1, 2, 3 ];         vs.     var arr = [1, 2, 3];
   ///    f({a : 1, b : 2, c : 3});              f({a: 1, b: 2, c: 3});
   /// \endcode
+  /// \version 3.7
   bool SpacesInContainerLiterals;
 
   /// If ``true``, spaces may be inserted into C style casts.
   /// \code
   ///    true:                                  false:
   ///    x = ( int32 )y                 vs.     x = (int32)y
   /// \endcode
+  /// \version 3.7
   bool SpacesInCStyleCastParentheses;
 
   /// Control of spaces within a single line comment
   struct SpacesInLineComment {
     /// The minimum number of spaces at the start of the comment.
     unsigned Minimum;
     /// The maximum number of spaces at the start of the comment.
     unsigned Maximum;
///    NS_TABLE_.*_END$"
   /// //  return true;                          //   return true;
   /// //}                                       // }
   ///
   /// Maximum: 0
   /// /// List:                                 ///List:
   /// ///  - Foo                                /// - Foo
   /// ///    - Bar                              ///   - Bar
   /// \endcode
+  /// \version 14
   SpacesInLineComment SpacesInLineCommentPrefix;
 
   /// If ``true``, spaces will be inserted after ``(`` and before ``)``.
   /// \code
   ///    true:                                  false:
   ///    t f( Deleted & ) & = delete;   vs.     t f(Deleted &) & = delete;
   /// \endcode
+  /// \version 3.7
   bool SpacesInParentheses;
 
   /// If ``true``, spaces will be inserted after ``[`` and before ``]``.
   /// Lambdas without arguments or unspecified size array declarations will not
   /// be affected.
   /// \code
   ///    true:                                  false:
   ///    int a[ 5 ];                    vs.     int a[5];
   ///    std::unique_ptr<int[]> foo() {} // Won't be affected
   /// \endcode
+  /// \version 3.7
   bool SpacesInSquareBrackets;
 
   /// If ``true``, spaces will be before  ``[``.
   /// Lambdas will not be affected. Only the first ``[`` will get a space added.
   /// \code
   ///    true:                                  false:
   ///    int a [5];                    vs.      int a[5];
   ///    int a [5][5];                 vs.      int a[5][5];
   /// \endcode
+  /// \version 11
   bool SpaceBeforeSquareBrackets;
 
   /// Styles for adding spacing around ``:`` in bitfield definitions.
   enum BitFieldColonSpacingStyle : unsigned char {
     /// Add one space on each side of the ``:``
     /// \code
     ///   unsigned bf : 2;
     /// \endcode
enum BitFieldColonSpacingStyle : unsigned char {
     /// Add space after the ``:`` only (space may be added before if
     /// needed for ``AlignConsecutiveBitFields``).
     /// \code
     ///   unsigned bf: 2;
     /// \endcode
     BFCS_After
   };
   /// The BitFieldColonSpacingStyle to use for bitfields.
+  /// \version 13
   BitFieldColonSpacingStyle BitFieldColonSpacing;
 
   /// Supported language standards for parsing and formatting C++ constructs.
   /// \code
   ///    Latest:                                vector<set<int>>
   ///    c++03                          vs.     vector<set<int> >
   /// \endcode
   ///
enum LanguageStandard : unsigned char {
     LS_Auto,
   };
 
   /// Parse and format C++ constructs compatible with this standard.
   /// \code
   ///    c++03:                                 latest:
   ///    vector<set<int> > x;           vs.     vector<set<int>> x;
   /// \endcode
+  /// \version 3.7
   LanguageStandard Standard;
 
   /// Macros which are ignored in front of a statement, as if they were an
   /// attribute. So that they are not parsed as identifier, for example for Qts
   /// emit.
   /// \code
   ///   AlignConsecutiveDeclarations: true
   ///   StatementAttributeLikeMacros: []
   ///   unsigned char data = 'x';
   ///   emit          signal(data); // This is parsed as variable declaration.
   ///
   ///   AlignConsecutiveDeclarations: true
   ///   StatementAttributeLikeMacros: [emit]
   ///   unsigned char data = 'x';
   ///   emit signal(data); // Now it's fine again.
   /// \endcode
+  /// \version 13
   std::vector<std::string> StatementAttributeLikeMacros;
 
   /// The number of columns used for tab stops.
+  /// \version 3.7
   unsigned TabWidth;
 
   /// Different ways to use tab in formatting.
   enum UseTabStyle : unsigned char {
     /// Never use tab.
     UT_Never,
     /// Use tabs only for indentation.
     UT_ForIndentation,
     /// Fill all leading whitespace with tabs, and use spaces for alignment that
     /// appears within a line (e.g. consecutive assignments and declarations).
     UT_ForContinuationAndIndentation,
     /// Use tabs for line continuation and indentation, and spaces for
     /// alignment.
     UT_AlignWithSpaces,
     /// Use tabs whenever we need to fill whitespace that spans at least from
     /// one tab stop to the next one.
     UT_Always
   };
 
   /// \brief Use ``\r\n`` instead of ``\n`` for line breaks.
   /// Also used as fallback if ``DeriveLineEnding`` is true.
+  /// \version 11
   bool UseCRLF;
 
   /// The way to use tab characters in the resulting file.
+  /// \version 3.7
   UseTabStyle UseTab;
 
   bool operator==(const FormatStyle &R) const {
     return AccessModifierOffset == R.AccessModifierOffset &&
            AlignAfterOpenBracket == R.AlignAfterOpenBracket &&
            AlignArrayOfStructures == R.AlignArrayOfStructures &&
            AlignConsecutiveAssignments == R.AlignConsecutiveAssignments &&
            AlignConsecutiveBitFields == R.AlignConsecutiveBitFields &&

clang/include/clang/Tooling/Inclusions/IncludeStyle.h

enum IncludeBlocksStyle {
     ///    #include <lib/main.h>
     ///    #include "a.h"                         #include <lib/main.h>
     /// \endcode
     IBS_Regroup,
   };
 
   /// Dependent on the value, multiple ``#include`` blocks can be sorted
   /// as one and divided based on category.
+  /// \version 7
   IncludeBlocksStyle IncludeBlocks;
 
   /// See documentation of ``IncludeCategories``.
   struct IncludeCategory {
     /// The regular expression that this category matches.
     std::string Regex;
     /// The priority to assign to this category.
     int Priority;
struct IncludeStyle {
   ///     - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
   ///       Priority:        3
   ///     - Regex:           '<[[:alnum:].]+>'
   ///       Priority:        4
   ///     - Regex:           '.*'
   ///       Priority:        1
   ///       SortPriority:    0
   /// \endcode
+  /// \version 7
   std::vector<IncludeCategory> IncludeCategories;
 
   /// Specify a regular expression of suffixes that are allowed in the
   /// file-to-main-include mapping.
   ///
   /// When guessing whether a #include is the "main" include (to assign
   /// category 0, see above), use this regex of allowed suffixes to the header
   /// stem. A partial match is done, so that:
   /// - "" means "arbitrary suffix"
   /// - "$" means "no suffix"
   ///
   /// For example, if configured to "(_test)?$", then a header a.h would be seen
   /// as the "main" include in both a.cc and a_test.cc.
+  /// \version 7
   std::string IncludeIsMainRegex;
 
   /// Specify a regular expression for files being formatted
   /// that are allowed to be considered "main" in the
   /// file-to-main-include mapping.
   ///
   /// By default, clang-format considers files as "main" only when they end
   /// with: ``.c``, ``.cc``, ``.cpp``, ``.c++``, ``.cxx``, ``.m`` or ``.mm``
   /// extensions.
   /// For these files a guessing of "main" include takes place
   /// (to assign category 0, see above). This config option allows for
   /// additional suffixes and extensions for files to be considered as "main".
   ///
   /// For example, if this option is configured to ``(Impl\.hpp)$``,
   /// then a file ``ClassImpl.hpp`` is considered "main" (in addition to
   /// ``Class.c``, ``Class.cc``, ``Class.cpp`` and so on) and "main
   /// include file" logic will be executed (with *IncludeIsMainRegex* setting
   /// also being respected in later phase). Without this option set,
   /// ``ClassImpl.hpp`` would not have the main include file put on top
   /// before any other include.
+  /// \version 7
   std::string IncludeIsMainSourceRegex;
 };
 
 } // namespace tooling
 } // namespace clang
 
 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::tooling::IncludeStyle::IncludeCategory)