This is an archive of the discontinued LLVM Phabricator instance.

Differential D19028

clang-format: Implemented tab usage for continuation and indentation
ClosedPublic

Authored by mxbOctasic on Apr 12 2016, 1:15 PM.

Details

Reviewers
djasper
Commits
rG51fe279fbbae: clang-format: Implemented tab usage for continuation and indentation
rC266320: clang-format: Implemented tab usage for continuation and indentation
rL266320: clang-format: Implemented tab usage for continuation and indentation
Summary

Adds a new tab usage mode.
Use tabs to fill whitespace at the start of a line.

Diff Detail

Repository
rL LLVM

Event Timeline

mxbOctasic updated this revision to Diff 53444.Apr 12 2016, 1:15 PM
mxbOctasic retitled this revision from to clang-format: Implemented tab usage for continuation and indentation.
mxbOctasic updated this object.
mxbOctasic added a reviewer: djasper.
mxbOctasic added a subscriber: cameron314.
Herald added a subscriber: klimek. · View Herald TranscriptApr 12 2016, 1:15 PM
djasper accepted this revision.Apr 12 2016, 1:37 PM
djasper edited edge metadata.

Always add cfe-commits as a subscriber. Otherwise looks good.

This revision is now accepted and ready to land.Apr 12 2016, 1:37 PM
mxbOctasic edited edge metadata.Apr 12 2016, 1:43 PM
mxbOctasic added a subscriber: cfe-commits.
Closed by commit rL266320: clang-format: Implemented tab usage for continuation and indentation (authored by mamai). · Explain WhyApr 14 2016, 7:58 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
cfe/
trunk/
include/
clang/
Format/
2 lines
lib/
Format/
2 lines
8 lines
unittests/
Format/
226 lines

Diff 53721

cfe/trunk/include/clang/Format/Format.h

Show First 20 Lines • Show All 597 Lines • ▼ Show 20 Linesstruct FormatStyle {
unsigned TabWidth; unsigned TabWidth;
/// \brief Different ways to use tab in formatting. /// \brief Different ways to use tab in formatting.
enum UseTabStyle { enum UseTabStyle {
/// Never use tab. /// Never use tab.
UT_Never, UT_Never,
/// Use tabs only for indentation. /// Use tabs only for indentation.
UT_ForIndentation, UT_ForIndentation,
/// Use tabs only for line continuation and indentation.
UT_ForContinuationAndIndentation,
/// Use tabs whenever we need to fill whitespace that spans at least from /// Use tabs whenever we need to fill whitespace that spans at least from
/// one tab stop to the next one. /// one tab stop to the next one.
UT_Always UT_Always
}; };
/// \brief The way to use tab characters in the resulting file. /// \brief The way to use tab characters in the resulting file.
UseTabStyle UseTab; UseTabStyle UseTab;
▲ Show 20 Lines • Show All 226 Lines • Show Last 20 Lines

cfe/trunk/lib/Format/Format.cpp

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> { template <> struct ScalarEnumerationTraits<FormatStyle::UseTabStyle> {
static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) { static void enumeration(IO &IO, FormatStyle::UseTabStyle &Value) {
IO.enumCase(Value, "Never", FormatStyle::UT_Never); IO.enumCase(Value, "Never", FormatStyle::UT_Never);
IO.enumCase(Value, "false", FormatStyle::UT_Never); IO.enumCase(Value, "false", FormatStyle::UT_Never);
IO.enumCase(Value, "Always", FormatStyle::UT_Always); IO.enumCase(Value, "Always", FormatStyle::UT_Always);
IO.enumCase(Value, "true", FormatStyle::UT_Always); IO.enumCase(Value, "true", FormatStyle::UT_Always);
IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation); IO.enumCase(Value, "ForIndentation", FormatStyle::UT_ForIndentation);
IO.enumCase(Value, "ForContinuationAndIndentation",
FormatStyle::UT_ForContinuationAndIndentation);
} }
}; };
template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> { template <> struct ScalarEnumerationTraits<FormatStyle::JavaScriptQuoteStyle> {
static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) { static void enumeration(IO &IO, FormatStyle::JavaScriptQuoteStyle &Value) {
IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave); IO.enumCase(Value, "Leave", FormatStyle::JSQS_Leave);
IO.enumCase(Value, "Single", FormatStyle::JSQS_Single); IO.enumCase(Value, "Single", FormatStyle::JSQS_Single);
IO.enumCase(Value, "Double", FormatStyle::JSQS_Double); IO.enumCase(Value, "Double", FormatStyle::JSQS_Double);
▲ Show 20 Lines • Show All 2,105 Lines • Show Last 20 Lines

cfe/trunk/lib/Format/WhitespaceManager.cpp

Show First 20 Lines • Show All 552 Lines • ▼ Show 20 Lines if (WhitespaceStartColumn == 0) {
if (Indentation > Spaces) if (Indentation > Spaces)
Indentation = Spaces; Indentation = Spaces;
unsigned Tabs = Indentation / Style.TabWidth; unsigned Tabs = Indentation / Style.TabWidth;
Text.append(Tabs, '\t'); Text.append(Tabs, '\t');
Spaces -= Tabs * Style.TabWidth; Spaces -= Tabs * Style.TabWidth;
} }
Text.append(Spaces, ' '); Text.append(Spaces, ' ');
break; break;
case FormatStyle::UT_ForContinuationAndIndentation:
if (WhitespaceStartColumn == 0) {
unsigned Tabs = Spaces / Style.TabWidth;
Text.append(Tabs, '\t');
Spaces -= Tabs * Style.TabWidth;
}
Text.append(Spaces, ' ');
break;
} }
} }
} // namespace format } // namespace format
} // namespace clang } // namespace clang

cfe/trunk/unittests/Format/FormatTest.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 8,566 Lines • ▼ Show 20 Lines EXPECT_EQ("{\n"
" int i;\n" " int i;\n"
"}", "}",
format("{\n" format("{\n"
"\t/*\n" "\t/*\n"
"\t * Comment\n" "\t * Comment\n"
"\t */\n" "\t */\n"
"\t int i;\n" "\t int i;\n"
"}")); "}"));
Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
Tab.TabWidth = 8;
Tab.IndentWidth = 8;
EXPECT_EQ("if (aaaaaaaa && // q\n"
" bb) // w\n"
"\t;",
format("if (aaaaaaaa &&// q\n"
"bb)// w\n"
";",
Tab));
EXPECT_EQ("if (aaa && bbb) // w\n"
"\t;",
format("if(aaa&&bbb)// w\n"
";",
Tab));
verifyFormat("class X {\n"
"\tvoid f() {\n"
"\t\tsomeFunction(parameter1,\n"
"\t\t\t parameter2);\n"
"\t}\n"
"};",
Tab);
verifyFormat("#define A \\\n"
"\tvoid f() { \\\n"
"\t\tsomeFunction( \\\n"
"\t\t parameter1, \\\n"
"\t\t parameter2); \\\n"
"\t}",
Tab);
Tab.TabWidth = 4;
Tab.IndentWidth = 8;
verifyFormat("class TabWidth4Indent8 {\n"
"\t\tvoid f() {\n"
"\t\t\t\tsomeFunction(parameter1,\n"
"\t\t\t\t\t\t\t parameter2);\n"
"\t\t}\n"
"};",
Tab);
Tab.TabWidth = 4;
Tab.IndentWidth = 4;
verifyFormat("class TabWidth4Indent4 {\n"
"\tvoid f() {\n"
"\t\tsomeFunction(parameter1,\n"
"\t\t\t\t\t parameter2);\n"
"\t}\n"
"};",
Tab);
Tab.TabWidth = 8;
Tab.IndentWidth = 4;
verifyFormat("class TabWidth8Indent4 {\n"
" void f() {\n"
"\tsomeFunction(parameter1,\n"
"\t\t parameter2);\n"
" }\n"
"};",
Tab);
Tab.TabWidth = 8;
Tab.IndentWidth = 8;
EXPECT_EQ("/*\n"
"\t a\t\tcomment\n"
"\t in multiple lines\n"
" */",
format(" /*\t \t \n"
" \t \t a\t\tcomment\t \t\n"
" \t \t in multiple lines\t\n"
" \t */",
Tab));
verifyFormat("{\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
"};",
Tab);
verifyFormat("enum AA {\n"
"\ta1, // Force multiple lines\n"
"\ta2,\n"
"\ta3\n"
"};",
Tab);
EXPECT_EQ("if (aaaaaaaa && // q\n"
" bb) // w\n"
"\t;",
format("if (aaaaaaaa &&// q\n"
"bb)// w\n"
";",
Tab));
verifyFormat("class X {\n"
"\tvoid f() {\n"
"\t\tsomeFunction(parameter1,\n"
"\t\t\t parameter2);\n"
"\t}\n"
"};",
Tab);
verifyFormat("{\n"
"\tQ(\n"
"\t {\n"
"\t\t int a;\n"
"\t\t someFunction(aaaaaaaa,\n"
"\t\t\t\t bbbbbbb);\n"
"\t },\n"
"\t p);\n"
"}",
Tab);
EXPECT_EQ("{\n"
"\t/* aaaa\n"
"\t bbbb */\n"
"}",
format("{\n"
"/* aaaa\n"
" bbbb */\n"
"}",
Tab));
EXPECT_EQ("{\n"
"\t/*\n"
"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
"\t bbbbbbbbbbbbb\n"
"\t*/\n"
"}",
format("{\n"
"/*\n"
" aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
"*/\n"
"}",
Tab));
EXPECT_EQ("{\n"
"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
"\t// bbbbbbbbbbbbb\n"
"}",
format("{\n"
"\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
"}",
Tab));
EXPECT_EQ("{\n"
"\t/*\n"
"\t aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
"\t bbbbbbbbbbbbb\n"
"\t*/\n"
"}",
format("{\n"
"\t/*\n"
"\t aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
"\t*/\n"
"}",
Tab));
EXPECT_EQ("{\n"
"\t/*\n"
"\n"
"\t*/\n"
"}",
format("{\n"
"\t/*\n"
"\n"
"\t*/\n"
"}",
Tab));
EXPECT_EQ("{\n"
"\t/*\n"
" asdf\n"
"\t*/\n"
"}",
format("{\n"
"\t/*\n"
" asdf\n"
"\t*/\n"
"}",
Tab));
EXPECT_EQ("/*\n"
"\t a\t\tcomment\n"
"\t in multiple lines\n"
" */",
format(" /*\t \t \n"
" \t \t a\t\tcomment\t \t\n"
" \t \t in multiple lines\t\n"
" \t */",
Tab));
EXPECT_EQ("/* some\n"
" comment */",
format(" \t \t /* some\n"
" \t \t comment */",
Tab));
EXPECT_EQ("int a; /* some\n"
" comment */",
format(" \t \t int a; /* some\n"
" \t \t comment */",
Tab));
EXPECT_EQ("int a; /* some\n"
"comment */",
format(" \t \t int\ta; /* some\n"
" \t \t comment */",
Tab));
EXPECT_EQ("f(\"\t\t\"); /* some\n"
" comment */",
format(" \t \t f(\"\t\t\"); /* some\n"
" \t \t comment */",
Tab));
EXPECT_EQ("{\n"
" /*\n"
" * Comment\n"
" */\n"
" int i;\n"
"}",
format("{\n"
"\t/*\n"
"\t * Comment\n"
"\t */\n"
"\t int i;\n"
"}"));
Tab.AlignConsecutiveAssignments = true;
Tab.AlignConsecutiveDeclarations = true;
Tab.TabWidth = 4;
Tab.IndentWidth = 4;
verifyFormat("class Assign {\n"
"\tvoid f() {\n"
"\t\tint x = 123;\n"
"\t\tint random = 4;\n"
"\t\tstd::string alphabet =\n"
"\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
"\t}\n"
"};",
Tab);
} }
TEST_F(FormatTest, CalculatesOriginalColumn) { TEST_F(FormatTest, CalculatesOriginalColumn) {
EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
"q\"; /* some\n" "q\"; /* some\n"
" comment */", " comment */",
format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n" format(" \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
"q\"; /* some\n" "q\"; /* some\n"
▲ Show 20 Lines • Show All 1,427 Lines • ▼ Show 20 Lines CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
FormatStyle::BAS_DontAlign); FormatStyle::BAS_DontAlign);
CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket, CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
FormatStyle::BAS_Align); FormatStyle::BAS_Align);
Style.UseTab = FormatStyle::UT_ForIndentation; Style.UseTab = FormatStyle::UT_ForIndentation;
CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never); CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation); CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always); CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
FormatStyle::UT_ForContinuationAndIndentation);
// For backward compatibility: // For backward compatibility:
CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never); CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always); CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline; Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
CHECK_PARSE("AllowShortFunctionsOnASingleLine: None", CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None); AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline", CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
▲ Show 20 Lines • Show All 1,273 Lines • Show Last 20 Lines