1//===--- WhitespaceManager.cpp - Format C++ code --------------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9/// 10/// \file 11/// \brief This file implements WhitespaceManager class. 12/// 13//===----------------------------------------------------------------------===// 14 15#include "WhitespaceManager.h" 16#include "llvm/ADT/STLExtras.h" 17 18namespace clang { 19namespace format { 20 21bool WhitespaceManager::Change::IsBeforeInFile:: 22operator()(const Change &C1, const Change &C2) const { 23 return SourceMgr.isBeforeInTranslationUnit( 24 C1.OriginalWhitespaceRange.getBegin(), 25 C2.OriginalWhitespaceRange.getBegin()); 26} 27 28WhitespaceManager::Change::Change( 29 bool CreateReplacement, SourceRange OriginalWhitespaceRange, 30 unsigned IndentLevel, int Spaces, unsigned StartOfTokenColumn, 31 unsigned NewlinesBefore, StringRef PreviousLinePostfix, 32 StringRef CurrentLinePrefix, tok::TokenKind Kind, bool ContinuesPPDirective, 33 bool IsStartOfDeclName, bool IsInsideToken) 34 : CreateReplacement(CreateReplacement), 35 OriginalWhitespaceRange(OriginalWhitespaceRange), 36 StartOfTokenColumn(StartOfTokenColumn), NewlinesBefore(NewlinesBefore), 37 PreviousLinePostfix(PreviousLinePostfix), 38 CurrentLinePrefix(CurrentLinePrefix), Kind(Kind), 39 ContinuesPPDirective(ContinuesPPDirective), 40 IsStartOfDeclName(IsStartOfDeclName), IndentLevel(IndentLevel), 41 Spaces(Spaces), IsInsideToken(IsInsideToken), IsTrailingComment(false), 42 TokenLength(0), PreviousEndOfTokenColumn(0), EscapedNewlineColumn(0), 43 StartOfBlockComment(nullptr), IndentationOffset(0) {} 44 45void WhitespaceManager::reset() { 46 Changes.clear(); 47 Replaces.clear(); 48} 49 50void WhitespaceManager::replaceWhitespace(FormatToken &Tok, unsigned Newlines, 51 unsigned IndentLevel, unsigned Spaces, 52 unsigned StartOfTokenColumn, 53 bool InPPDirective) { 54 if (Tok.Finalized) 55 return; 56 Tok.Decision = (Newlines > 0) ? FD_Break : FD_Continue; 57 Changes.push_back( 58 Change(/*CreateReplacement=*/true, Tok.WhitespaceRange, IndentLevel, 59 Spaces, StartOfTokenColumn, Newlines, "", "", Tok.Tok.getKind(), 60 InPPDirective && !Tok.IsFirst, 61 Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName), 62 /*IsInsideToken=*/false)); 63} 64 65void WhitespaceManager::addUntouchableToken(const FormatToken &Tok, 66 bool InPPDirective) { 67 if (Tok.Finalized) 68 return; 69 Changes.push_back(Change( 70 /*CreateReplacement=*/false, Tok.WhitespaceRange, /*IndentLevel=*/0, 71 /*Spaces=*/0, Tok.OriginalColumn, Tok.NewlinesBefore, "", "", 72 Tok.Tok.getKind(), InPPDirective && !Tok.IsFirst, 73 Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName), 74 /*IsInsideToken=*/false)); 75} 76 77void WhitespaceManager::replaceWhitespaceInToken( 78 const FormatToken &Tok, unsigned Offset, unsigned ReplaceChars, 79 StringRef PreviousPostfix, StringRef CurrentPrefix, bool InPPDirective, 80 unsigned Newlines, unsigned IndentLevel, int Spaces) { 81 if (Tok.Finalized) 82 return; 83 SourceLocation Start = Tok.getStartOfNonWhitespace().getLocWithOffset(Offset); 84 Changes.push_back(Change( 85 true, SourceRange(Start, Start.getLocWithOffset(ReplaceChars)), 86 IndentLevel, Spaces, std::max(0, Spaces), Newlines, PreviousPostfix, 87 CurrentPrefix, Tok.is(TT_LineComment) ? tok::comment : tok::unknown, 88 InPPDirective && !Tok.IsFirst, 89 Tok.is(TT_StartOfName) || Tok.is(TT_FunctionDeclarationName), 90 /*IsInsideToken=*/Newlines == 0)); 91} 92 93const tooling::Replacements &WhitespaceManager::generateReplacements() { 94 if (Changes.empty()) 95 return Replaces; 96 97 std::sort(Changes.begin(), Changes.end(), Change::IsBeforeInFile(SourceMgr)); 98 calculateLineBreakInformation(); 99 alignConsecutiveDeclarations(); 100 alignConsecutiveAssignments(); 101 alignTrailingComments(); 102 alignEscapedNewlines(); 103 generateChanges(); 104 105 return Replaces; 106} 107 108void WhitespaceManager::calculateLineBreakInformation() { 109 Changes[0].PreviousEndOfTokenColumn = 0; 110 Change *LastOutsideTokenChange = &Changes[0]; 111 for (unsigned i = 1, e = Changes.size(); i != e; ++i) { 112 unsigned OriginalWhitespaceStart = 113 SourceMgr.getFileOffset(Changes[i].OriginalWhitespaceRange.getBegin()); 114 unsigned PreviousOriginalWhitespaceEnd = SourceMgr.getFileOffset( 115 Changes[i - 1].OriginalWhitespaceRange.getEnd()); 116 Changes[i - 1].TokenLength = OriginalWhitespaceStart - 117 PreviousOriginalWhitespaceEnd + 118 Changes[i].PreviousLinePostfix.size() + 119 Changes[i - 1].CurrentLinePrefix.size(); 120 121 // If there are multiple changes in this token, sum up all the changes until 122 // the end of the line. 123 if (Changes[i - 1].IsInsideToken) 124 LastOutsideTokenChange->TokenLength += 125 Changes[i - 1].TokenLength + Changes[i - 1].Spaces; 126 else 127 LastOutsideTokenChange = &Changes[i - 1]; 128 129 Changes[i].PreviousEndOfTokenColumn = 130 Changes[i - 1].StartOfTokenColumn + Changes[i - 1].TokenLength; 131 132 Changes[i - 1].IsTrailingComment = 133 (Changes[i].NewlinesBefore > 0 || Changes[i].Kind == tok::eof || 134 (Changes[i].IsInsideToken && Changes[i].Kind == tok::comment)) && 135 Changes[i - 1].Kind == tok::comment; 136 } 137 // FIXME: The last token is currently not always an eof token; in those 138 // cases, setting TokenLength of the last token to 0 is wrong. 139 Changes.back().TokenLength = 0; 140 Changes.back().IsTrailingComment = Changes.back().Kind == tok::comment; 141 142 const WhitespaceManager::Change *LastBlockComment = nullptr; 143 for (auto &Change : Changes) { 144 // Reset the IsTrailingComment flag for changes inside of trailing comments 145 // so they don't get realigned later. 146 if (Change.IsInsideToken) 147 Change.IsTrailingComment = false; 148 Change.StartOfBlockComment = nullptr; 149 Change.IndentationOffset = 0; 150 if (Change.Kind == tok::comment) { 151 LastBlockComment = &Change; 152 } else if (Change.Kind == tok::unknown) { 153 if ((Change.StartOfBlockComment = LastBlockComment)) 154 Change.IndentationOffset = 155 Change.StartOfTokenColumn - 156 Change.StartOfBlockComment->StartOfTokenColumn; 157 } else { 158 LastBlockComment = nullptr; 159 } 160 } 161} 162 163// Align a single sequence of tokens, see AlignTokens below. 164template <typename F> 165static void 166AlignTokenSequence(unsigned Start, unsigned End, unsigned Column, F &&Matches, 167 SmallVector<WhitespaceManager::Change, 16> &Changes) { 168 bool FoundMatchOnLine = false; 169 int Shift = 0; 170 for (unsigned i = Start; i != End; ++i) { 171 if (Changes[i].NewlinesBefore > 0) { 172 FoundMatchOnLine = false; 173 Shift = 0; 174 } 175 176 // If this is the first matching token to be aligned, remember by how many 177 // spaces it has to be shifted, so the rest of the changes on the line are 178 // shifted by the same amount 179 if (!FoundMatchOnLine && Matches(Changes[i])) { 180 FoundMatchOnLine = true; 181 Shift = Column - Changes[i].StartOfTokenColumn; 182 Changes[i].Spaces += Shift; 183 } 184 185 assert(Shift >= 0); 186 Changes[i].StartOfTokenColumn += Shift; 187 if (i + 1 != Changes.size()) 188 Changes[i + 1].PreviousEndOfTokenColumn += Shift; 189 } 190} 191 192// Walk through all of the changes and find sequences of matching tokens to 193// align. To do so, keep track of the lines and whether or not a matching token 194// was found on a line. If a matching token is found, extend the current 195// sequence. If the current line cannot be part of a sequence, e.g. because 196// there is an empty line before it or it contains only non-matching tokens, 197// finalize the previous sequence. 198template <typename F> 199static void AlignTokens(const FormatStyle &Style, F &&Matches, 200 SmallVector<WhitespaceManager::Change, 16> &Changes) { 201 unsigned MinColumn = 0; 202 unsigned MaxColumn = UINT_MAX; 203 204 // Line number of the start and the end of the current token sequence. 205 unsigned StartOfSequence = 0; 206 unsigned EndOfSequence = 0; 207 208 // Keep track of the nesting level of matching tokens, i.e. the number of 209 // surrounding (), [], or {}. We will only align a sequence of matching 210 // token that share the same scope depth. 211 // 212 // FIXME: This could use FormatToken::NestingLevel information, but there is 213 // an outstanding issue wrt the brace scopes. 214 unsigned NestingLevelOfLastMatch = 0; 215 unsigned NestingLevel = 0; 216 217 // Keep track of the number of commas before the matching tokens, we will only 218 // align a sequence of matching tokens if they are preceded by the same number 219 // of commas. 220 unsigned CommasBeforeLastMatch = 0; 221 unsigned CommasBeforeMatch = 0; 222 223 // Whether a matching token has been found on the current line. 224 bool FoundMatchOnLine = false; 225 226 // Aligns a sequence of matching tokens, on the MinColumn column. 227 // 228 // Sequences start from the first matching token to align, and end at the 229 // first token of the first line that doesn't need to be aligned. 230 // 231 // We need to adjust the StartOfTokenColumn of each Change that is on a line 232 // containing any matching token to be aligned and located after such token. 233 auto AlignCurrentSequence = [&] { 234 if (StartOfSequence > 0 && StartOfSequence < EndOfSequence) 235 AlignTokenSequence(StartOfSequence, EndOfSequence, MinColumn, Matches, 236 Changes); 237 MinColumn = 0; 238 MaxColumn = UINT_MAX; 239 StartOfSequence = 0; 240 EndOfSequence = 0; 241 }; 242 243 for (unsigned i = 0, e = Changes.size(); i != e; ++i) { 244 if (Changes[i].NewlinesBefore != 0) { 245 CommasBeforeMatch = 0; 246 EndOfSequence = i; 247 // If there is a blank line, or if the last line didn't contain any 248 // matching token, the sequence ends here. 249 if (Changes[i].NewlinesBefore > 1 || !FoundMatchOnLine) 250 AlignCurrentSequence(); 251 252 FoundMatchOnLine = false; 253 } 254 255 if (Changes[i].Kind == tok::comma) { 256 ++CommasBeforeMatch; 257 } else if (Changes[i].Kind == tok::r_brace || 258 Changes[i].Kind == tok::r_paren || 259 Changes[i].Kind == tok::r_square) { 260 --NestingLevel; 261 } else if (Changes[i].Kind == tok::l_brace || 262 Changes[i].Kind == tok::l_paren || 263 Changes[i].Kind == tok::l_square) { 264 // We want sequences to skip over child scopes if possible, but not the 265 // other way around. 266 NestingLevelOfLastMatch = std::min(NestingLevelOfLastMatch, NestingLevel); 267 ++NestingLevel; 268 } 269 270 if (!Matches(Changes[i])) 271 continue; 272 273 // If there is more than one matching token per line, or if the number of 274 // preceding commas, or the scope depth, do not match anymore, end the 275 // sequence. 276 if (FoundMatchOnLine || CommasBeforeMatch != CommasBeforeLastMatch || 277 NestingLevel != NestingLevelOfLastMatch) 278 AlignCurrentSequence(); 279 280 CommasBeforeLastMatch = CommasBeforeMatch; 281 NestingLevelOfLastMatch = NestingLevel; 282 FoundMatchOnLine = true; 283 284 if (StartOfSequence == 0) 285 StartOfSequence = i; 286 287 unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn; 288 int LineLengthAfter = -Changes[i].Spaces; 289 for (unsigned j = i; j != e && Changes[j].NewlinesBefore == 0; ++j) 290 LineLengthAfter += Changes[j].Spaces + Changes[j].TokenLength; 291 unsigned ChangeMaxColumn = Style.ColumnLimit - LineLengthAfter; 292 293 // If we are restricted by the maximum column width, end the sequence. 294 if (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn || 295 CommasBeforeLastMatch != CommasBeforeMatch) { 296 AlignCurrentSequence(); 297 StartOfSequence = i; 298 } 299 300 MinColumn = std::max(MinColumn, ChangeMinColumn); 301 MaxColumn = std::min(MaxColumn, ChangeMaxColumn); 302 } 303 304 EndOfSequence = Changes.size(); 305 AlignCurrentSequence(); 306} 307 308void WhitespaceManager::alignConsecutiveAssignments() { 309 if (!Style.AlignConsecutiveAssignments) 310 return; 311 312 AlignTokens(Style, 313 [&](const Change &C) { 314 // Do not align on equal signs that are first on a line. 315 if (C.NewlinesBefore > 0) 316 return false; 317 318 // Do not align on equal signs that are last on a line. 319 if (&C != &Changes.back() && (&C + 1)->NewlinesBefore > 0) 320 return false; 321 322 return C.Kind == tok::equal; 323 }, 324 Changes); 325} 326 327void WhitespaceManager::alignConsecutiveDeclarations() { 328 if (!Style.AlignConsecutiveDeclarations) 329 return; 330 331 // FIXME: Currently we don't handle properly the PointerAlignment: Right 332 // The * and & are not aligned and are left dangling. Something has to be done 333 // about it, but it raises the question of alignment of code like: 334 // const char* const* v1; 335 // float const* v2; 336 // SomeVeryLongType const& v3; 337 338 AlignTokens(Style, [](Change const &C) { return C.IsStartOfDeclName; }, 339 Changes); 340} 341 342void WhitespaceManager::alignTrailingComments() { 343 unsigned MinColumn = 0; 344 unsigned MaxColumn = UINT_MAX; 345 unsigned StartOfSequence = 0; 346 bool BreakBeforeNext = false; 347 unsigned Newlines = 0; 348 for (unsigned i = 0, e = Changes.size(); i != e; ++i) { 349 if (Changes[i].StartOfBlockComment) 350 continue; 351 Newlines += Changes[i].NewlinesBefore; 352 if (!Changes[i].IsTrailingComment) 353 continue; 354 355 unsigned ChangeMinColumn = Changes[i].StartOfTokenColumn; 356 unsigned ChangeMaxColumn = Style.ColumnLimit - Changes[i].TokenLength; 357 358 // If we don't create a replacement for this change, we have to consider 359 // it to be immovable. 360 if (!Changes[i].CreateReplacement) 361 ChangeMaxColumn = ChangeMinColumn; 362 363 if (i + 1 != e && Changes[i + 1].ContinuesPPDirective) 364 ChangeMaxColumn -= 2; 365 // If this comment follows an } in column 0, it probably documents the 366 // closing of a namespace and we don't want to align it. 367 bool FollowsRBraceInColumn0 = i > 0 && Changes[i].NewlinesBefore == 0 && 368 Changes[i - 1].Kind == tok::r_brace && 369 Changes[i - 1].StartOfTokenColumn == 0; 370 bool WasAlignedWithStartOfNextLine = false; 371 if (Changes[i].NewlinesBefore == 1) { // A comment on its own line. 372 unsigned CommentColumn = SourceMgr.getSpellingColumnNumber( 373 Changes[i].OriginalWhitespaceRange.getEnd()); 374 for (unsigned j = i + 1; j != e; ++j) { 375 if (Changes[j].Kind != tok::comment) { // Skip over comments. 376 unsigned NextColumn = SourceMgr.getSpellingColumnNumber( 377 Changes[j].OriginalWhitespaceRange.getEnd()); 378 // The start of the next token was previously aligned with the 379 // start of this comment. 380 WasAlignedWithStartOfNextLine = 381 CommentColumn == NextColumn || 382 CommentColumn == NextColumn + Style.IndentWidth; 383 break; 384 } 385 } 386 } 387 if (!Style.AlignTrailingComments || FollowsRBraceInColumn0) { 388 alignTrailingComments(StartOfSequence, i, MinColumn); 389 MinColumn = ChangeMinColumn; 390 MaxColumn = ChangeMinColumn; 391 StartOfSequence = i; 392 } else if (BreakBeforeNext || Newlines > 1 || 393 (ChangeMinColumn > MaxColumn || ChangeMaxColumn < MinColumn) || 394 // Break the comment sequence if the previous line did not end 395 // in a trailing comment. 396 (Changes[i].NewlinesBefore == 1 && i > 0 && 397 !Changes[i - 1].IsTrailingComment) || 398 WasAlignedWithStartOfNextLine) { 399 alignTrailingComments(StartOfSequence, i, MinColumn); 400 MinColumn = ChangeMinColumn; 401 MaxColumn = ChangeMaxColumn; 402 StartOfSequence = i; 403 } else { 404 MinColumn = std::max(MinColumn, ChangeMinColumn); 405 MaxColumn = std::min(MaxColumn, ChangeMaxColumn); 406 } 407 BreakBeforeNext = 408 (i == 0) || (Changes[i].NewlinesBefore > 1) || 409 // Never start a sequence with a comment at the beginning of 410 // the line. 411 (Changes[i].NewlinesBefore == 1 && StartOfSequence == i); 412 Newlines = 0; 413 } 414 alignTrailingComments(StartOfSequence, Changes.size(), MinColumn); 415} 416 417void WhitespaceManager::alignTrailingComments(unsigned Start, unsigned End, 418 unsigned Column) { 419 for (unsigned i = Start; i != End; ++i) { 420 int Shift = 0; 421 if (Changes[i].IsTrailingComment) { 422 Shift = Column - Changes[i].StartOfTokenColumn; 423 } 424 if (Changes[i].StartOfBlockComment) { 425 Shift = Changes[i].IndentationOffset + 426 Changes[i].StartOfBlockComment->StartOfTokenColumn - 427 Changes[i].StartOfTokenColumn; 428 } 429 assert(Shift >= 0); 430 Changes[i].Spaces += Shift; 431 if (i + 1 != End) 432 Changes[i + 1].PreviousEndOfTokenColumn += Shift; 433 Changes[i].StartOfTokenColumn += Shift; 434 } 435} 436 437void WhitespaceManager::alignEscapedNewlines() { 438 unsigned MaxEndOfLine = 439 Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit; 440 unsigned StartOfMacro = 0; 441 for (unsigned i = 1, e = Changes.size(); i < e; ++i) { 442 Change &C = Changes[i]; 443 if (C.NewlinesBefore > 0) { 444 if (C.ContinuesPPDirective) { 445 MaxEndOfLine = std::max(C.PreviousEndOfTokenColumn + 2, MaxEndOfLine); 446 } else { 447 alignEscapedNewlines(StartOfMacro + 1, i, MaxEndOfLine); 448 MaxEndOfLine = Style.AlignEscapedNewlinesLeft ? 0 : Style.ColumnLimit; 449 StartOfMacro = i; 450 } 451 } 452 } 453 alignEscapedNewlines(StartOfMacro + 1, Changes.size(), MaxEndOfLine); 454} 455 456void WhitespaceManager::alignEscapedNewlines(unsigned Start, unsigned End, 457 unsigned Column) { 458 for (unsigned i = Start; i < End; ++i) { 459 Change &C = Changes[i]; 460 if (C.NewlinesBefore > 0) { 461 assert(C.ContinuesPPDirective); 462 if (C.PreviousEndOfTokenColumn + 1 > Column) 463 C.EscapedNewlineColumn = 0; 464 else 465 C.EscapedNewlineColumn = Column; 466 } 467 } 468} 469 470void WhitespaceManager::generateChanges() { 471 for (unsigned i = 0, e = Changes.size(); i != e; ++i) { 472 const Change &C = Changes[i]; 473 if (i > 0) { 474 assert(Changes[i - 1].OriginalWhitespaceRange.getBegin() != 475 C.OriginalWhitespaceRange.getBegin() && 476 "Generating two replacements for the same location"); 477 } 478 if (C.CreateReplacement) { 479 std::string ReplacementText = C.PreviousLinePostfix; 480 if (C.ContinuesPPDirective) 481 appendNewlineText(ReplacementText, C.NewlinesBefore, 482 C.PreviousEndOfTokenColumn, C.EscapedNewlineColumn); 483 else 484 appendNewlineText(ReplacementText, C.NewlinesBefore); 485 appendIndentText(ReplacementText, C.IndentLevel, std::max(0, C.Spaces), 486 C.StartOfTokenColumn - std::max(0, C.Spaces)); 487 ReplacementText.append(C.CurrentLinePrefix); 488 storeReplacement(C.OriginalWhitespaceRange, ReplacementText); 489 } 490 } 491} 492 493void WhitespaceManager::storeReplacement(SourceRange Range, 494 StringRef Text) { 495 unsigned WhitespaceLength = SourceMgr.getFileOffset(Range.getEnd()) - 496 SourceMgr.getFileOffset(Range.getBegin()); 497 // Don't create a replacement, if it does not change anything. 498 if (StringRef(SourceMgr.getCharacterData(Range.getBegin()), 499 WhitespaceLength) == Text) 500 return; 501 Replaces.insert(tooling::Replacement( 502 SourceMgr, CharSourceRange::getCharRange(Range), Text)); 503} 504 505void WhitespaceManager::appendNewlineText(std::string &Text, 506 unsigned Newlines) { 507 for (unsigned i = 0; i < Newlines; ++i) 508 Text.append(UseCRLF ? "\r\n" : "\n"); 509} 510 511void WhitespaceManager::appendNewlineText(std::string &Text, unsigned Newlines, 512 unsigned PreviousEndOfTokenColumn, 513 unsigned EscapedNewlineColumn) { 514 if (Newlines > 0) { 515 unsigned Offset = 516 std::min<int>(EscapedNewlineColumn - 1, PreviousEndOfTokenColumn); 517 for (unsigned i = 0; i < Newlines; ++i) { 518 Text.append(EscapedNewlineColumn - Offset - 1, ' '); 519 Text.append(UseCRLF ? "\\\r\n" : "\\\n"); 520 Offset = 0; 521 } 522 } 523} 524 525void WhitespaceManager::appendIndentText(std::string &Text, 526 unsigned IndentLevel, unsigned Spaces, 527 unsigned WhitespaceStartColumn) { 528 switch (Style.UseTab) { 529 case FormatStyle::UT_Never: 530 Text.append(Spaces, ' '); 531 break; 532 case FormatStyle::UT_Always: { 533 unsigned FirstTabWidth = 534 Style.TabWidth - WhitespaceStartColumn % Style.TabWidth; 535 // Indent with tabs only when there's at least one full tab. 536 if (FirstTabWidth + Style.TabWidth <= Spaces) { 537 Spaces -= FirstTabWidth; 538 Text.append("\t"); 539 } 540 Text.append(Spaces / Style.TabWidth, '\t'); 541 Text.append(Spaces % Style.TabWidth, ' '); 542 break; 543 } 544 case FormatStyle::UT_ForIndentation: 545 if (WhitespaceStartColumn == 0) { 546 unsigned Indentation = IndentLevel * Style.IndentWidth; 547 // This happens, e.g. when a line in a block comment is indented less than 548 // the first one. 549 if (Indentation > Spaces) 550 Indentation = Spaces; 551 unsigned Tabs = Indentation / Style.TabWidth; 552 Text.append(Tabs, '\t'); 553 Spaces -= Tabs * Style.TabWidth; 554 } 555 Text.append(Spaces, ' '); 556 break; 557 } 558} 559 560} // namespace format 561} // namespace clang 562