link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

This is an archive of the discontinued LLVM Phabricator instance.

Paths

-

clang/
-

docs/
2/3

ClangFormatStyleOptions.rst
-

include/clang/Format/
-

clang/
-

Format/
-

Format.h
-

lib/Format/
-

Format/
-

Format.cpp
-

FormatToken.h
1/1

FormatTokenLexer.cpp
-

TokenAnnotator.cpp
-

unittests/Format/
-

Format/
5/5

FormatTest.cpp

JakeMerdichAMD on Jun 25 2020, 7:16 PM.

Details

Reviewers

Commits

rG0c332a7784c6: [clang-format] Preserve whitespace in selected macros

https://bugs.llvm.org/show_bug.cgi?id=46383

When the c preprocessor stringizes tokens, the generated string literals
are affected by the whitespace. This means clang-format can affect
codegen silently, adding spaces and newlines to strings. Practically
speaking, the vast majority of cases will be harmless, only affecting
single identifiers or debug macros.

In the interest of doing no harm in other cases though, this introduces
a blacklist option 'WhitespaceSensitiveMacros', which contains a list of
names of function-like macros whose contents should not be touched by
clang-format, period. Clang-format can't automatically detect these
without a real compile context, so users will have to specify it
explicitly (it still beats clang-format off'ing at every invocation).

I added one default, "STRINGIZE", but am not particularly attached to
it, nor have I given much thought to defaults.

Diff Detail

Repository: rG LLVM Github Monorepo

Event Timeline

JakeMerdichAMD created this revision. Jun 25 2020, 7:16 PM

JakeMerdichAMD added reviewers: MyDeveloperDay , curdeius , sammccall , jbcoe . Jun 25 2020, 7:21 PM

JakeMerdichAMD added a project: .

curdeius added inline comments. Jun 26 2020, 12:57 AM


	Shouldn't there be a configuration example like what's in `ForEachMacros` doc? In the .clang-format configuration file, this can be configured like: .. code-block:: yaml WhitespaceSensitiveMacros: ['STRINGIZE', 'PP_STRINGIZE'] For example: BOOST_PP_STRINGIZE.

	Personally I would add braces around the loop body.

	Shouldn't that be: `CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",` as in other options that take vector of strings?
	Ditto: apostrophes around strings.
	How about a test with escaped parentheses `\(` inside the macro argument?

JakeMerdichAMD marked 10 inline comments as done. Jun 26 2020, 7:05 AM

JakeMerdichAMD added inline comments.


	Done. I also added PP_STRINGIZE and BOOST_PP_STRINGIZE as defaults; seems reasonable.

	I'll add it since it ought to be tested, but they aren't required to my knowledge due to 'YAML reasons' and most of the other tests omit them.
	Done. Note that parens always need to be matched anyhow, and the escaping doesn't actually mean anything outside of a string literal (tested on MSVC, gcc, clang), so no functionality change is needed.

Address feedback (nits, better docs, more defaults)

Thanks for the fast review, @curdeius , and thanks for mentioning PP_STRINGIZE and BOOST_PP_STRINGIZE too!

LGTM

This revision is now accepted and ready to land. Jun 26 2020, 10:03 AM

curdeius accepted this revision. Jun 26 2020, 11:33 AM

LGTM. Thank you for taking my comments into account.

Closed by commit rG0c332a7784c6: [clang-format] Preserve whitespace in selected macros (authored by JakeMerdichAMD ). · Explain Why Jun 29 2020, 7:01 AM

This revision was automatically updated to reflect the committed changes.

MyDeveloperDay added inline comments. Jul 3 2020, 8:40 AM


	The change I think you made here gets lost when the ClangFormatOptions.rst file is regenerated Could you update the `Format.h` and regenerate rather than making the code changes in the rst itself? I ran into this issue when I tried to regenerate.

benhamilton mentioned this in D89425: [Format/ObjC] Add NS_SWIFT_NAME() and CF_SWIFT_NAME() to WhitespaceSensitiveMacros . Oct 14 2020, 1:36 PM

benhamilton mentioned this in rGe7b4feea8e1b: [Format/ObjC] Add NS_SWIFT_NAME() and CF_SWIFT_NAME() to… . Oct 14 2020, 2:44 PM

Revision Contents

Path

Size

clang/

docs/

ClangFormatStyleOptions.rst

17 lines

include/

clang/

Format/

Format.h

11 lines

lib/

Format/

Format.cpp

5 lines

FormatToken.h

1 line

FormatTokenLexer.cpp

5 lines

TokenAnnotator.cpp

30 lines

unittests/

Format/

FormatTest.cpp

43 lines

Diff	ID	Base	Description	Created	Lint	Unit
Base			Base
Diff 1	273579	b2303de		Jun 25 2020, 7:16 PM	★	★
Diff 2	273722	431daed	Address feedback (nits, better docs, more defaults)	Jun 26 2020, 7:09 AM	★	★
Diff 3	274102	3b95d83	rG0c332a7784c649038bd237a60fa18b45a3dea90d	Jun 29 2020, 6:57 AM	★	★

Diff 274102

	Show First 20 Lines • Show All 1,419 Lines • ▼ Show 20 Lines
	/// NAMESPACE(<namespace-name>, ...) {			/// NAMESPACE(<namespace-name>, ...) {
	/// <namespace-content>			/// <namespace-content>
	/// }			/// }
	/// \endcode			/// \endcode
	/// For example: TESTSUITE			/// For example: TESTSUITE
	std :: vector < std :: string > NamespaceMacros ;			std :: vector < std :: string > NamespaceMacros ;
				/// A vector of macros which are whitespace-sensitive and shouldn't be
				/// touched.
				/// These are expected to be macros of the form:
				/// \code
				/// STRINGIZE(...)
				/// \endcode
				/// For example: STRINGIZE
				std :: vector < std :: string > WhitespaceSensitiveMacros ;
	tooling :: IncludeStyle IncludeStyle ;			tooling :: IncludeStyle IncludeStyle ;
	/// Indent case labels one level from the switch statement.			/// Indent case labels one level from the switch statement.
	/// When ``false``, use the same indentation level as for the switch			/// When ``false``, use the same indentation level as for the switch
	/// statement. Switch statement body is always indented one level more than			/// statement. Switch statement body is always indented one level more than
	/// case labels (except the first block following the case label, which			/// case labels (except the first block following the case label, which
	/// itself indents the code - unless IndentCaseBlocks is enabled).			/// itself indents the code - unless IndentCaseBlocks is enabled).
	▲ Show 20 Lines • Show All 1,238 Lines • Show Last 20 Lines

Show First 20 Lines • Show All 593 Lines • ▼ Show 20 Lines	static void mapping ( IO & IO , FormatStyle & Style ) {
IO . mapOptional ( "SpaceBeforeSquareBrackets" ,		IO . mapOptional ( "SpaceBeforeSquareBrackets" ,
Style . SpaceBeforeSquareBrackets );		Style . SpaceBeforeSquareBrackets );
IO . mapOptional ( "Standard" , Style . Standard );		IO . mapOptional ( "Standard" , Style . Standard );
IO . mapOptional ( "StatementMacros" , Style . StatementMacros );		IO . mapOptional ( "StatementMacros" , Style . StatementMacros );
IO . mapOptional ( "TabWidth" , Style . TabWidth );		IO . mapOptional ( "TabWidth" , Style . TabWidth );
IO . mapOptional ( "TypenameMacros" , Style . TypenameMacros );		IO . mapOptional ( "TypenameMacros" , Style . TypenameMacros );
IO . mapOptional ( "UseCRLF" , Style . UseCRLF );		IO . mapOptional ( "UseCRLF" , Style . UseCRLF );
IO . mapOptional ( "UseTab" , Style . UseTab );		IO . mapOptional ( "UseTab" , Style . UseTab );
		IO . mapOptional ( "WhitespaceSensitiveMacros" ,
		Style . WhitespaceSensitiveMacros );
template <> struct MappingTraits < FormatStyle :: BraceWrappingFlags > {		template <> struct MappingTraits < FormatStyle :: BraceWrappingFlags > {
static void mapping ( IO & IO , FormatStyle :: BraceWrappingFlags & Wrapping ) {		static void mapping ( IO & IO , FormatStyle :: BraceWrappingFlags & Wrapping ) {
IO . mapOptional ( "AfterCaseLabel" , Wrapping . AfterCaseLabel );		IO . mapOptional ( "AfterCaseLabel" , Wrapping . AfterCaseLabel );
IO . mapOptional ( "AfterClass" , Wrapping . AfterClass );		IO . mapOptional ( "AfterClass" , Wrapping . AfterClass );
IO . mapOptional ( "AfterControlStatement" , Wrapping . AfterControlStatement );		IO . mapOptional ( "AfterControlStatement" , Wrapping . AfterControlStatement );
▲ Show 20 Lines • Show All 318 Lines • ▼ Show 20 Lines	FormatStyle getLLVMStyle ( FormatStyle :: LanguageKind Language ) {
LLVMStyle . PenaltyBreakBeforeFirstCallParameter = 19 ;		LLVMStyle . PenaltyBreakBeforeFirstCallParameter = 19 ;
LLVMStyle . PenaltyBreakTemplateDeclaration = prec :: Relational ;		LLVMStyle . PenaltyBreakTemplateDeclaration = prec :: Relational ;
LLVMStyle . DisableFormat = false ;		LLVMStyle . DisableFormat = false ;
LLVMStyle . SortIncludes = true ;		LLVMStyle . SortIncludes = true ;
LLVMStyle . SortUsingDeclarations = true ;		LLVMStyle . SortUsingDeclarations = true ;
LLVMStyle . StatementMacros . push_back ( "Q_UNUSED" );		LLVMStyle . StatementMacros . push_back ( "Q_UNUSED" );
LLVMStyle . StatementMacros . push_back ( "QT_REQUIRE_VERSION" );		LLVMStyle . StatementMacros . push_back ( "QT_REQUIRE_VERSION" );
		LLVMStyle . WhitespaceSensitiveMacros . push_back ( "STRINGIZE" );
		LLVMStyle . WhitespaceSensitiveMacros . push_back ( "PP_STRINGIZE" );
		LLVMStyle . WhitespaceSensitiveMacros . push_back ( "BOOST_PP_STRINGIZE" );
// Defaults that differ when not C++.		// Defaults that differ when not C++.
if ( Language == FormatStyle :: LK_TableGen ) {		if ( Language == FormatStyle :: LK_TableGen ) {
LLVMStyle . SpacesInContainerLiterals = false ;		LLVMStyle . SpacesInContainerLiterals = false ;
return LLVMStyle ;		return LLVMStyle ;
▲ Show 20 Lines • Show All 1,924 Lines • Show Last 20 Lines

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 Lines	#define LIST_TOKEN_TYPES \
TYPE(TemplateOpener) \		TYPE(TemplateOpener) \
TYPE(TemplateString) \		TYPE(TemplateString) \
TYPE(ProtoExtensionLSquare) \		TYPE(ProtoExtensionLSquare) \
TYPE(TrailingAnnotation) \		TYPE(TrailingAnnotation) \
TYPE(TrailingReturnArrow) \		TYPE(TrailingReturnArrow) \
TYPE(TrailingUnaryOperator) \		TYPE(TrailingUnaryOperator) \
TYPE(TypenameMacro) \		TYPE(TypenameMacro) \
TYPE(UnaryOperator) \		TYPE(UnaryOperator) \
		TYPE(UntouchableMacroFunc) \
TYPE ( CSharpStringLiteral ) \		TYPE(CSharpStringLiteral) \
TYPE ( CSharpNamedArgumentColon ) \		TYPE(CSharpNamedArgumentColon) \
TYPE ( CSharpNullable ) \		TYPE(CSharpNullable) \
TYPE ( CSharpNullCoalescing ) \		TYPE(CSharpNullCoalescing) \
TYPE ( CSharpNullConditional ) \		TYPE(CSharpNullConditional) \
TYPE ( CSharpNullConditionalLSquare ) \		TYPE(CSharpNullConditionalLSquare) \
TYPE ( CSharpGenericTypeConstraint ) \		TYPE(CSharpGenericTypeConstraint) \
TYPE ( CSharpGenericTypeConstraintColon ) \		TYPE(CSharpGenericTypeConstraintColon) \
▲ Show 20 Lines • Show All 948 Lines • Show Last 20 Lines

Show All 37 Lines	FormatTokenLexer :: FormatTokenLexer ( const SourceManager & SourceMgr , FileID ID ,
for ( const std :: string & ForEachMacro : Style . ForEachMacros )		for ( const std :: string & ForEachMacro : Style . ForEachMacros )
Macros . insert ({ & IdentTable . get ( ForEachMacro ), TT_ForEachMacro });		Macros . insert ({ & IdentTable . get ( ForEachMacro ), TT_ForEachMacro });
for ( const std :: string & StatementMacro : Style . StatementMacros )		for ( const std :: string & StatementMacro : Style . StatementMacros )
Macros . insert ({ & IdentTable . get ( StatementMacro ), TT_StatementMacro });		Macros . insert ({ & IdentTable . get ( StatementMacro ), TT_StatementMacro });
for ( const std :: string & TypenameMacro : Style . TypenameMacros )		for ( const std :: string & TypenameMacro : Style . TypenameMacros )
Macros . insert ({ & IdentTable . get ( TypenameMacro ), TT_TypenameMacro });		Macros . insert ({ & IdentTable . get ( TypenameMacro ), TT_TypenameMacro });
for ( const std :: string & NamespaceMacro : Style . NamespaceMacros )		for ( const std :: string & NamespaceMacro : Style . NamespaceMacros )
Macros . insert ({ & IdentTable . get ( NamespaceMacro ), TT_NamespaceMacro });		Macros . insert ({ & IdentTable . get ( NamespaceMacro ), TT_NamespaceMacro });
		for ( const std :: string & WhitespaceSensitiveMacro :
		Style . WhitespaceSensitiveMacros ) {
		Macros . insert (
		{ & IdentTable . get ( WhitespaceSensitiveMacro ), TT_UntouchableMacroFunc });
		curdeius Unsubmitted Reply Inline Actions Personally I would add braces around the loop body. curdeius: Personally I would add braces around the loop body.
		}
ArrayRef < FormatToken *> FormatTokenLexer :: lex () {		ArrayRef < FormatToken *> FormatTokenLexer :: lex () {
assert ( Tokens . empty ());		assert ( Tokens . empty ());
assert ( FirstInLineIndex == 0 );		assert ( FirstInLineIndex == 0 );
do {		do {
Tokens . push_back ( getNextToken ());		Tokens . push_back ( getNextToken ());
if ( Style . Language == FormatStyle :: LK_JavaScript ) {		if ( Style . Language == FormatStyle :: LK_JavaScript ) {
▲ Show 20 Lines • Show All 1,018 Lines • Show Last 20 Lines

Show First 20 Lines • Show All 154 Lines • ▼ Show 20 Lines	while ( CurrentToken ) {
if ( ! consumeToken ())		if ( ! consumeToken ())
return false ;		return false ;
return false ;		return false ;
		bool parseUntouchableParens () {
		while ( CurrentToken ) {
		CurrentToken -> Finalized = true ;
		switch ( CurrentToken -> Tok . getKind ()) {
		case tok :: l_paren :
		next ();
		if ( ! parseUntouchableParens ())
		return false ;
		continue ;
		case tok :: r_paren :
		next ();
		return true ;
		default :
		// no-op
		break ;
		next ();
		return false ;
bool parseParens ( bool LookForDecls = false ) {		bool parseParens ( bool LookForDecls = false ) {
if ( ! CurrentToken )		if ( ! CurrentToken )
return false ;		return false ;
FormatToken * Left = CurrentToken -> Previous ;		FormatToken * Left = CurrentToken -> Previous ;
Left -> ParentBracket = Contexts . back (). ContextKind ;		Left -> ParentBracket = Contexts . back (). ContextKind ;
ScopedContextCreator ContextCreator ( * this , tok :: l_paren , 1 );		ScopedContextCreator ContextCreator ( * this , tok :: l_paren , 1 );
// FIXME: This is a bit of a hack. Do better.		// FIXME: This is a bit of a hack. Do better.
Contexts . back (). ColonIsForRangeExpr =		Contexts . back (). ColonIsForRangeExpr =
Contexts . size () == 2 && Contexts [ 0 ]. ColonIsForRangeExpr ;		Contexts . size () == 2 && Contexts [ 0 ]. ColonIsForRangeExpr ;
		if ( Left -> Previous && Left -> Previous -> is ( TT_UntouchableMacroFunc )) {
		Left -> Finalized = true ;
		return parseUntouchableParens ();
bool StartsObjCMethodExpr = false ;		bool StartsObjCMethodExpr = false ;
if ( FormatToken * MaybeSel = Left -> Previous ) {		if ( FormatToken * MaybeSel = Left -> Previous ) {
// @selector( starts a selector.		// @selector( starts a selector.
if ( MaybeSel -> isObjCAtKeyword ( tok :: objc_selector ) && MaybeSel -> Previous &&		if ( MaybeSel -> isObjCAtKeyword ( tok :: objc_selector ) && MaybeSel -> Previous &&
MaybeSel -> Previous -> is ( tok :: at )) {		MaybeSel -> Previous -> is ( tok :: at )) {
StartsObjCMethodExpr = true ;		StartsObjCMethodExpr = true ;
▲ Show 20 Lines • Show All 1,124 Lines • ▼ Show 20 Lines	void resetTokenMetadata ( FormatToken * Token ) {
// Reset token type in case we have already looked at it and then		// Reset token type in case we have already looked at it and then
// recovered from an error (e.g. failure to find the matching >).		// recovered from an error (e.g. failure to find the matching >).
if ( ! CurrentToken -> isOneOf (		if ( ! CurrentToken -> isOneOf (
TT_LambdaLSquare , TT_LambdaLBrace , TT_ForEachMacro ,		TT_LambdaLSquare , TT_LambdaLBrace , TT_ForEachMacro ,
TT_TypenameMacro , TT_FunctionLBrace , TT_ImplicitStringLiteral ,		TT_TypenameMacro , TT_FunctionLBrace , TT_ImplicitStringLiteral ,
TT_InlineASMBrace , TT_JsFatArrow , TT_LambdaArrow , TT_NamespaceMacro ,		TT_InlineASMBrace , TT_JsFatArrow , TT_LambdaArrow , TT_NamespaceMacro ,
TT_OverloadedOperator , TT_RegexLiteral , TT_TemplateString ,		TT_OverloadedOperator , TT_RegexLiteral , TT_TemplateString ,
TT_ObjCStringLiteral ))		TT_ObjCStringLiteral , TT_UntouchableMacroFunc ))
CurrentToken -> setType ( TT_Unknown );		CurrentToken -> setType ( TT_Unknown );
CurrentToken -> Role . reset ();		CurrentToken -> Role . reset ();
CurrentToken -> MatchingParen = nullptr ;		CurrentToken -> MatchingParen = nullptr ;
CurrentToken -> FakeLParens . clear ();		CurrentToken -> FakeLParens . clear ();
CurrentToken -> FakeRParens = 0 ;		CurrentToken -> FakeRParens = 0 ;
void next () {		void next () {
▲ Show 20 Lines • Show All 2,642 Lines • ▼ Show 20 Lines
void TokenAnnotator :: printDebugInfo ( const AnnotatedLine & Line ) {		void TokenAnnotator :: printDebugInfo ( const AnnotatedLine & Line ) {
llvm :: errs () << "AnnotatedTokens(L=" << Line . Level << "): \n " ;		llvm :: errs () << "AnnotatedTokens(L=" << Line . Level << "): \n " ;
const FormatToken * Tok = Line . First ;		const FormatToken * Tok = Line . First ;
while ( Tok ) {		while ( Tok ) {
llvm :: errs () << " M=" << Tok -> MustBreakBefore		llvm :: errs () << " M=" << Tok -> MustBreakBefore
<< " C=" << Tok -> CanBreakBefore		<< " C=" << Tok -> CanBreakBefore
<< " T=" << getTokenTypeName ( Tok -> getType ())		<< " T=" << getTokenTypeName ( Tok -> getType ())
<< " S=" << Tok -> SpacesRequiredBefore		<< " S=" << Tok -> SpacesRequiredBefore
<< " B=" << Tok -> BlockParameterCount		<< " F=" << Tok -> Finalized << " B=" << Tok -> BlockParameterCount
<< " BK=" << Tok -> BlockKind << " P=" << Tok -> SplitPenalty		<< " BK=" << Tok -> BlockKind << " P=" << Tok -> SplitPenalty
<< " Name=" << Tok -> Tok . getName () << " L=" << Tok -> TotalLength		<< " Name=" << Tok -> Tok . getName () << " L=" << Tok -> TotalLength
<< " PPK=" << Tok -> PackingKind << " FakeLParens=" ;		<< " PPK=" << Tok -> PackingKind << " FakeLParens=" ;
for ( unsigned i = 0 , e = Tok -> FakeLParens . size (); i != e ; ++ i )		for ( unsigned i = 0 , e = Tok -> FakeLParens . size (); i != e ; ++ i )
llvm :: errs () << Tok -> FakeLParens [ i ] << "/" ;		llvm :: errs () << Tok -> FakeLParens [ i ] << "/" ;
llvm :: errs () << " FakeRParens=" << Tok -> FakeRParens ;		llvm :: errs () << " FakeRParens=" << Tok -> FakeRParens ;
llvm :: errs () << " II=" << Tok -> Tok . getIdentifierInfo ();		llvm :: errs () << " II=" << Tok -> Tok . getIdentifierInfo ();
llvm :: errs () << " Text='" << Tok -> TokenText << "' \n " ;		llvm :: errs () << " Text='" << Tok -> TokenText << "' \n " ;
Show All 9 Lines

This file is larger than 256 KB, so syntax highlighting is disabled by default.

Show First 20 Lines • Show All 14,015 Lines • ▼ Show 20 Lines	CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));		std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
Style.NamespaceMacros.clear();		Style.NamespaceMacros.clear();
CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,		CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
std::vector<std::string>{"TESTSUITE"});		std::vector<std::string>{"TESTSUITE"});
CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,		CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
std::vector<std::string>({"TESTSUITE", "SUITE"}));		std::vector<std::string>({"TESTSUITE", "SUITE"}));
		Style.WhitespaceSensitiveMacros.clear();
		CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
		curdeius Unsubmitted Reply Inline Actions Shouldn't that be: `CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",` as in other options that take vector of strings? curdeius: Shouldn't that be: `CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",` as in other…
		JakeMerdichAMD Author Unsubmitted Reply Inline Actions I'll add it since it ought to be tested, but they aren't required to my knowledge due to 'YAML reasons' and most of the other tests omit them. JakeMerdichAMD: I'll add it since it ought to be tested, but they aren't required to my knowledge due to 'YAML…
		WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
		CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
		curdeius Unsubmitted Reply Inline Actions Ditto: apostrophes around strings. curdeius: Ditto: apostrophes around strings.
		WhitespaceSensitiveMacros,
		std::vector<std::string>({"STRINGIZE", "ASSERT"}));
		Style.WhitespaceSensitiveMacros.clear();
		CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
		WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
		CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
		WhitespaceSensitiveMacros,
		std::vector<std::string>({"STRINGIZE", "ASSERT"}));
Style.IncludeStyle.IncludeCategories.clear();		Style.IncludeStyle.IncludeCategories.clear();
std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {		std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
{"abc/.", 2, 0}, {".", 1, 0}};		{"abc/.", 2, 0}, {".", 1, 0}};
CHECK_PARSE("IncludeCategories:\n"		CHECK_PARSE("IncludeCategories:\n"
" - Regex: abc/.*\n"		" - Regex: abc/.*\n"
" Priority: 2\n"		" Priority: 2\n"
" - Regex: .*\n"		" - Regex: .*\n"
" Priority: 1",		" Priority: 1",
▲ Show 20 Lines • Show All 2,493 Lines • ▼ Show 20 Lines	TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
verifyFormat("foo(operator+, -42);", Style);		verifyFormat("foo(operator+, -42);", Style);
verifyFormat("foo(operator++, -42);", Style);		verifyFormat("foo(operator++, -42);", Style);
verifyFormat("foo(operator--, -42);", Style);		verifyFormat("foo(operator--, -42);", Style);
verifyFormat("foo(-42, operator--);", Style);		verifyFormat("foo(-42, operator--);", Style);
verifyFormat("foo(-42, operator, );", Style);		verifyFormat("foo(-42, operator, );", Style);
verifyFormat("foo(operator, , -42);", Style);		verifyFormat("foo(operator, , -42);", Style);
		TEST_F(FormatTest, WhitespaceSensitiveMacros) {
		FormatStyle Style = getLLVMStyle();
		Style.WhitespaceSensitiveMacros.push_back("FOO");
		// Don't use the helpers here, since 'mess up' will change the whitespace
		// and these are all whitespace sensitive by definition
		EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
		curdeius Unsubmitted Reply Inline Actions How about a test with escaped parentheses `\(` inside the macro argument? curdeius: How about a test with escaped parentheses `\(` inside the macro argument?
		JakeMerdichAMD Author Unsubmitted Reply Inline Actions Done. Note that parens always need to be matched anyhow, and the escaping doesn't actually mean anything outside of a string literal (tested on MSVC, gcc, clang), so no functionality change is needed. JakeMerdichAMD: Done. Note that parens always need to be matched anyhow, and the escaping doesn't actually mean…
		format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
		EXPECT_EQ(
		"FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
		format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
		EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
		format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
		EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
		" Still=Intentional);",
		format("FOO(String-ized&Messy+But,: :\n"
		" Still=Intentional);",
		Style));
		Style.AlignConsecutiveAssignments = true;
		EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
		" Still=Intentional);",
		format("FOO(String-ized=&Messy+But,: :\n"
		" Still=Intentional);",
		Style));
		Style.ColumnLimit = 21;
		EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
		format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {		TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
// These tests are not in NamespaceFixer because that doesn't		// These tests are not in NamespaceFixer because that doesn't
// test its interaction with line wrapping		// test its interaction with line wrapping
FormatStyle Style = getLLVMStyle();		FormatStyle Style = getLLVMStyle();
Style.ColumnLimit = 80;		Style.ColumnLimit = 80;
verifyFormat("namespace {\n"

This is an archive of the discontinued LLVM Phabricator instance.

[clang-format] Preserve whitespace in selected macros Closed Public (adsbygoogle = window.adsbygoogle || []).push({});

Details

Diff Detail

Event Timeline

Revision Contents

Diff 274102

clang/docs/ClangFormatStyleOptions.rst

clang/include/clang/Format/Format.h

clang/lib/Format/Format.cpp

clang/lib/Format/FormatToken.h

clang/lib/Format/FormatTokenLexer.cpp

clang/lib/Format/TokenAnnotator.cpp

clang/unittests/Format/FormatTest.cpp