[clang-format] Add PPIndentWidth option

[gergap]

Summary

This allows to set a different indent width for preprocessor statements.

Example:

#ifdef __linux_
# define FOO
#endif

int main(void)
{
    return 0;
}

[gergap]

fixing test issues

[HazardyKnusperkeks]

Love it!

But this will result in unexpected (one might say breaking) behaviour, if someone set IndentWidth to a different value than his base style and update clang-format without adding a setting for PPIndentWidth. So in my opinion it should have a different default value, which always picks up IndentWidth until PPIndentWidth is explicitly set. Either some form of optional, or for me -1 is also fine, but I know others are more reluctant to use -1.

clang/unittests/Format/FormatTest.cpp

3438

How about the other IndentPPDirectives values?

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

2336

I prefer alphabetical sorting, I know there are some entries which aren't sorted.

[MyDeveloperDay]

clang/unittests/Format/FormatTest.cpp

3447

can you add a test

#ifdef X
   void foo() {
       ...
   }
#endif

its unclear if PPIndentWidth affects code in #ifdef or just # preprocessor instructions

[gergap]

I fixed the review findings and changed the behavior to be better backwards compatible by using PPIndentWidth=-1 by default.
This value defaults to IndentWidth now.

clang/unittests/Format/FormatTest.cpp

3447

It does not affect the code. It works in the same way as IndentWidth.
I updated the test cases now to verify this.

[gergap]

fix review findings

[HazardyKnusperkeks]

Looks good to me, I would just change the wording a bit. Could you please also add a entry in the ReleaseNotes.rst?

clang/include/clang/Format/Format.h

2675

Not only backwards compatibility, but you can always choose to match those two.

[gergap]

changed wording as requested and updated release notes

[gergap]

@HazardyKnusperkeks could you please land this for me?

[gergap]

trigger build again

[HazardyKnusperkeks]

clang/include/clang/Format/Format.h

2686

I've replaced this with int, because signed results in an exception from dump_format_style.py.

clang/docs/ClangFormatStyleOptions.rst

.. code-block:: c++
 
      void f() {
         someFunction();
         if (true, false) {
            f();
         }
      }
 
+**PPIndentWidth** (``unsigned``)
+  The number of columns to use for indentation of preprocessor statements.
+
+  .. code-block:: c++
+
+     PPIndentWidth: 1
+
+     #ifdef __linux__
+     # define FOO
+     #else
+     # define BAR
+     #endif
+
 **IndentWrappedFunctionNames** (``bool``)
   Indent if a function definition or declaration is wrapped after the
   type.
 
   .. code-block:: c++
 
      true:
      LoooooooooooooooooooooooooooooooooooooooongReturnType

clang/include/clang/Format/Format.h

   ///       someFunction();
   ///       if (true, false) {
   ///          f();
   ///       }
   ///    }
   /// \endcode
   unsigned IndentWidth;
 
+  /// The number of columns to use for indentation of preprocessor statements.
+  /// \code
+  ///    PPIndentWidth: 1
+  ///
+  ///    #ifdef __linux__
+  ///    # define FOO
+  ///    #else
+  ///    # define BAR
+  ///    #endif
+  /// \endcode
+  unsigned PPIndentWidth;
+
   /// Indent if a function definition or declaration is wrapped after the
   /// type.
   /// \code
   ///    true:
   ///    LoooooooooooooooooooooooooooooooooooooooongReturnType
   ///        LoooooooooooooooooooooooooooooooongFunctionDeclaration();
   ///
   ///    false:
enum PointerAlignmentStyle : unsigned char {
     /// \endcode
     PAS_Middle
   };
 
   /// Pointer and reference alignment style.
   PointerAlignmentStyle PointerAlignment;
 
   /// 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;
     /// A list of enclosing function names that match this language.
     std::vector<std::string> EnclosingFunctions;
     /// The canonical delimiter for this language.
     std::string CanonicalDelimiter;
     /// The style name on which this raw string format is based on.
     /// If not specified, the raw string format is based on the style that this
     /// format is based on.
     std::string BasedOnStyle;
     bool operator==(const RawStringFormat &Other) const {
       return Language == Other.Language && Delimiters == Other.Delimiters &&
              EnclosingFunctions == Other.EnclosingFunctions &&
              CanonicalDelimiter == Other.CanonicalDelimiter &&
              BasedOnStyle == Other.BasedOnStyle;
     }
   };

clang/lib/Format/Format.cpp

static void mapping(IO &IO, FormatStyle &Style) {
     IO.mapOptional("PenaltyBreakTemplateDeclaration",
                    Style.PenaltyBreakTemplateDeclaration);
     IO.mapOptional("PenaltyExcessCharacter", Style.PenaltyExcessCharacter);
     IO.mapOptional("PenaltyReturnTypeOnItsOwnLine",
                    Style.PenaltyReturnTypeOnItsOwnLine);
     IO.mapOptional("PenaltyIndentedWhitespace",
                    Style.PenaltyIndentedWhitespace);
     IO.mapOptional("PointerAlignment", Style.PointerAlignment);
+    IO.mapOptional("PPIndentWidth", Style.PPIndentWidth);
     IO.mapOptional("RawStringFormats", Style.RawStringFormats);
     IO.mapOptional("ReflowComments", Style.ReflowComments);
     IO.mapOptional("ShortNamespaceLines", Style.ShortNamespaceLines);
     IO.mapOptional("SortIncludes", Style.SortIncludes);
     IO.mapOptional("SortJavaStaticImport", Style.SortJavaStaticImport);
     IO.mapOptional("SortUsingDeclarations", Style.SortUsingDeclarations);
     IO.mapOptional("SpaceAfterCStyleCast", Style.SpaceAfterCStyleCast);
     IO.mapOptional("SpaceAfterLogicalNot", Style.SpaceAfterLogicalNot);
FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   LLVMStyle.IndentAccessModifiers = false;
   LLVMStyle.IndentCaseLabels = false;
   LLVMStyle.IndentCaseBlocks = false;
   LLVMStyle.IndentGotoLabels = true;
   LLVMStyle.IndentPPDirectives = FormatStyle::PPDIS_None;
   LLVMStyle.IndentRequires = false;
   LLVMStyle.IndentWrappedFunctionNames = false;
   LLVMStyle.IndentWidth = 2;
+  LLVMStyle.PPIndentWidth = 2; // default to old value
   LLVMStyle.InsertTrailingCommas = FormatStyle::TCS_None;
   LLVMStyle.JavaScriptQuotes = FormatStyle::JSQS_Leave;
   LLVMStyle.JavaScriptWrapImports = true;
   LLVMStyle.TabWidth = 8;
   LLVMStyle.MaxEmptyLinesToKeep = 1;
   LLVMStyle.KeepEmptyLinesAtTheStartOfBlocks = true;
   LLVMStyle.NamespaceIndentation = FormatStyle::NI_None;
   LLVMStyle.ObjCBinPackProtocolList = FormatStyle::BPS_Auto;
ChromiumStyle.IncludeStyle.IncludeBlocks =
       tooling::IncludeStyle::IBS_Preserve;
 
   if (Language == FormatStyle::LK_Java) {
     ChromiumStyle.AllowShortIfStatementsOnASingleLine =
         FormatStyle::SIS_WithoutElse;
     ChromiumStyle.BreakAfterJavaFieldAnnotations = true;
     ChromiumStyle.ContinuationIndentWidth = 8;
     ChromiumStyle.IndentWidth = 4;
+    ChromiumStyle.PPIndentWidth = 4; // default to old value
     // See styleguide for import groups:
     // https://chromium.googlesource.com/chromium/src/+/master/styleguide/java/java.md#Import-Order
     ChromiumStyle.JavaImportGroups = {
         "android",
         "androidx",
         "com",
         "dalvik",
         "junit",
FormatStyle getMozillaStyle() {
   MozillaStyle.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
   MozillaStyle.BinPackParameters = false;
   MozillaStyle.BinPackArguments = false;
   MozillaStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
   MozillaStyle.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
   MozillaStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
   MozillaStyle.ConstructorInitializerIndentWidth = 2;
   MozillaStyle.ContinuationIndentWidth = 2;
+  MozillaStyle.PPIndentWidth = 2; // default to old value
   MozillaStyle.Cpp11BracedListStyle = false;
   MozillaStyle.FixNamespaceComments = false;
   MozillaStyle.IndentCaseLabels = true;
   MozillaStyle.ObjCSpaceAfterProperty = true;
   MozillaStyle.ObjCSpaceBeforeProtocolList = false;
   MozillaStyle.PenaltyReturnTypeOnItsOwnLine = 200;
   MozillaStyle.PointerAlignment = FormatStyle::PAS_Left;
   MozillaStyle.SpaceAfterTemplateKeyword = false;
FormatStyle getWebKitStyle() {
   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
   Style.BreakBeforeBraces = FormatStyle::BS_WebKit;
   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
   Style.Cpp11BracedListStyle = false;
   Style.ColumnLimit = 0;
   Style.FixNamespaceComments = false;
   Style.IndentWidth = 4;
+  Style.PPIndentWidth = 4; // default to old value
   Style.NamespaceIndentation = FormatStyle::NI_Inner;
   Style.ObjCBlockIndentWidth = 4;
   Style.ObjCSpaceAfterProperty = true;
   Style.PointerAlignment = FormatStyle::PAS_Left;
   Style.SpaceBeforeCpp11BracedList = true;
   Style.SpaceInEmptyBlock = true;
   return Style;
 }
FormatStyle getGNUStyle() {
   return Style;
 }
 
 FormatStyle getMicrosoftStyle(FormatStyle::LanguageKind Language) {
   FormatStyle Style = getLLVMStyle(Language);
   Style.ColumnLimit = 120;
   Style.TabWidth = 4;
   Style.IndentWidth = 4;
+  Style.PPIndentWidth = 4; // default to old value
   Style.UseTab = FormatStyle::UT_Never;
   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
   Style.BraceWrapping.AfterClass = true;
   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
   Style.BraceWrapping.AfterEnum = true;
   Style.BraceWrapping.AfterFunction = true;
   Style.BraceWrapping.AfterNamespace = true;
   Style.BraceWrapping.AfterObjCDeclaration = true;

clang/lib/Format/UnwrappedLineFormatter.cpp

public:
   /// next.
   void nextLine(const AnnotatedLine &Line) {
     Offset = getIndentOffset(*Line.First);
     // Update the indent level cache size so that we can rely on it
     // having the right size in adjustToUnmodifiedline.
     while (IndentForLevel.size() <= Line.Level)
       IndentForLevel.push_back(-1);
     if (Line.InPPDirective) {
-      Indent = Line.Level * Style.IndentWidth + AdditionalIndent;
+      Indent = Line.Level * Style.PPIndentWidth + AdditionalIndent;
     } else {
       IndentForLevel.resize(Line.Level + 1);
       Indent = getIndent(IndentForLevel, Line.Level);
     }
     if (static_cast<int>(Indent) + Offset >= 0)
       Indent += Offset;
     if (Line.First->is(TT_CSharpGenericTypeConstraint))
       Indent = Line.Level * Style.IndentWidth + Style.ContinuationIndentWidth;

clang/unittests/Format/FormatTest.cpp

EXPECT_EQ("const char *c = STRINGIFY(\n"
             format("const char * c = STRINGIFY(\n"
                    "\\na : b);"));
 
   verifyFormat("a\r\\");
   verifyFormat("a\v\\");
   verifyFormat("a\f\\");
 }
 
+TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) {
+  FormatStyle style = getChromiumStyle(FormatStyle::LK_Cpp);
+  style.IndentWidth = 4;
+  style.PPIndentWidth = 1;
+  style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
+
+  verifyFormat("#ifdef __linux__\n"
+               "# define FOO\n"
+               "#endif\n"
+               "void foo() {\n"
+               "    int x = 0;\n"
+               "}\n",
+               style);
+}
+
 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
   // FIXME: We never break before the macro name.
   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
 
   verifyFormat("#define A A\n#define A A");
// Keep comments aligned with un-indented directives.
     EXPECT_EQ(Expected, format(ToFormat, Style));
     EXPECT_EQ(Expected, format(Expected, Style));
   }
   // Test AfterHash with tabs.
   {
     FormatStyle Tabbed = Style;
     Tabbed.UseTab = FormatStyle::UT_Always;
     Tabbed.IndentWidth = 8;
+    Tabbed.PPIndentWidth = 8;
     Tabbed.TabWidth = 8;
     verifyFormat("#ifdef _WIN32\n"
                  "#\tdefine A 0\n"
                  "#\tifdef VAR2\n"
                  "#\t\tdefine B 1\n"
                  "#\t\tinclude <someheader.h>\n"
                  "#\t\tdefine MACRO          \\\n"
                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
   verifyFormat("double\n"
                "f();",
                getLLVMStyleWithColumns(8));
 }
 
 TEST_F(FormatTest, ConfigurableUseOfTab) {
   FormatStyle Tab = getLLVMStyleWithColumns(42);
   Tab.IndentWidth = 8;
+  Tab.PPIndentWidth = 8;
   Tab.UseTab = FormatStyle::UT_Always;
   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
 
   EXPECT_EQ("if (aaaaaaaa && // q\n"
             "    bb)\t\t// w\n"
             "\t;",
             format("if (aaaaaaaa &&// q\n"
                    "bb)// w\n"
verifyFormat("class TabWidth4Indent8 {\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;
+  Tab.PPIndentWidth = 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;
+  Tab.PPIndentWidth = 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  */",
EXPECT_EQ("{\n"
                    "\t */\n"
                    "\t int i;\n"
                    "}",
                    Tab));
 
   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
+  Tab.PPIndentWidth = 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"
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;
+  Tab.PPIndentWidth = 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;
+  Tab.PPIndentWidth = 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  */",
verifyFormat("class Assign {\n"
                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
                "\t}\n"
                "};",
                Tab);
 
   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
   Tab.TabWidth = 8;
   Tab.IndentWidth = 8;
+  Tab.PPIndentWidth = 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"