[clang-format] Add possibility to be based on parent directory

[HazardyKnusperkeks]

Summary

This allows the define BasedOnStyle: InheritParentConfig and then clang-format looks into the parent directories for their .clang-format and takes that as a basis.

My use case is to remove the column limit for my tests.

[MyDeveloperDay]

I'm a little confused why this is needed as clang-format always read up the directory tree until it see a .clang-format file, perhaps I don't quite understand the use case. Can't you just have a different .clang-format in the subdirectory?

[HazardyKnusperkeks]

In D93844#2472346, @MyDeveloperDay wrote:

I'm a little confused why this is needed as clang-format always read up the directory tree until it see a .clang-format file, perhaps I don't quite understand the use case. Can't you just have a different .clang-format in the subdirectory?

Yes of course I can, but I don't want to copy everything except the one thing I want to change.

I have one .clang-format in my main directory and since I only want to change the column limit for my tests I want to write a .clang-format in the test directory with the content:

BasedOnStyle: File
ColumnLimit: 0

So when I change (or better add) a value in my main .clang-format it will also apply to my tests, without touching their file.

[njames93]

In D93844#2472346, @MyDeveloperDay wrote:

I'm a little confused why this is needed as clang-format always read up the directory tree until it see a .clang-format file, perhaps I don't quite understand the use case. Can't you just have a different .clang-format in the subdirectory?

It's my understanding this is akin to the InheritParentConfig option found in .clang-tidy.
The idea is you can put a .clang-format file in your project root, then for specific directories you can add another .clang-format file that modifies that root .clang-format
The example here is a test folder that needs extended lines but want the rest of the formatting to match the root folder without having to copy the contents of the root and make the small edit.

We have it quite lucky here at LLVM where for tests we can just use:

BasedOnStyle: LLVM
ColumnLimit: 0

However for other projects with their own style they could then use:

# Copy the root directory clang.format config
BasedOnStyle: file
ColumnLimit: 0

This would also make modifying the formatting style of a project much easier as you would only need to touch the root directory .clang-format file in most cases.

With this implementation I'm not too sure on the specifics though. .clang-format files are more complex to parse than .clang-tidy files so there's more edge cases to consider.
Also it appears this wouldn't handle the case of invoking clang-format with the style set inline on the command line.
clang-format <file> --style='{BasedOnStyle: File, ColumnLimit: 80}'
Should this then check the directory for .clang-format files?

clang/lib/Format/Format.cpp

3039

This seems a very inefficient way of doing this, getStyle does a lot of things we simple don't need to worry about. Maybe the file loading part should be extracted out into its own function, that can then recursively call itself. Or use the clang-tidy approach of storing configurations in a stack (will have to be unparsed cause how clang-format works) and then parse them on top of each other.

[HazardyKnusperkeks]

In D93844#2472352, @njames93 wrote:

In D93844#2472346, @MyDeveloperDay wrote:

I'm a little confused why this is needed as clang-format always read up the directory tree until it see a .clang-format file, perhaps I don't quite understand the use case. Can't you just have a different .clang-format in the subdirectory?

It's my understanding this is akin to the InheritParentConfig option found in .clang-tidy.
The idea is you can put a .clang-format file in your project root, then for specific directories you can add another .clang-format file that modifies that root .clang-format
The example here is a test folder that needs extended lines but want the rest of the formatting to match the root folder without having to copy the contents of the root and make the small edit.

We have it quite lucky here at LLVM where for tests we can just use:

BasedOnStyle: LLVM
ColumnLimit: 0

However for other projects with their own style they could then use:

# Copy the root directory clang.format config
BasedOnStyle: file
ColumnLimit: 0

This would also make modifying the formatting style of a project much easier as you would only need to touch the root directory .clang-format file in most cases.

Exactly.

With this implementation I'm not too sure on the specifics though. .clang-format files are more complex to parse than .clang-tidy files so there's more edge cases to consider.
Also it appears this wouldn't handle the case of invoking clang-format with the style set inline on the command line.
clang-format <file> --style='{BasedOnStyle: File, ColumnLimit: 80}'
Should this then check the directory for .clang-format files?

Initially I thought it shouldn't. But now I think maybe it should.

clang/lib/Format/Format.cpp

3039

Yeah I know that this is double work, but I thought it only affects the case BasedOnStyle: File and keeps the "normal" way untouched.

If I do build a stack I would actually parse all .clang-format files up to the root directory and in the not BasedOnStyle: File case throw away the results, wouldn't I? The question is how often someone has a .clang-fomrat in one of his parent directories which is not used because it got overwritten.

But I can do that.

Or is there an easy way to just check the BasedOnStyle value? As far as I understood the yaml code it parses the whole file into an internal structure and we only query this structure, right?

[MyDeveloperDay]

I like what you are suggesting, do you think BasedOnStyle: File is the best terminology as the term File is used elsewhere to mean read from the .clang_format file, how about

BasedOnStyle: Inherit
BasedOnStyle: InheritFromParent
BasedOnStyle: InheritFromFile

or why not just

BasedOnStyle: InheritParentConfig

to match clang-tidy?

[HazardyKnusperkeks]

In D93844#2473725, @MyDeveloperDay wrote:

I like what you are suggesting, do you think BasedOnStyle: File is the best terminology as the term File is used elsewhere to mean read from the .clang_format file, how about

BasedOnStyle: Inherit
BasedOnStyle: InheritFromParent
BasedOnStyle: InheritFromFile

or why not just

BasedOnStyle: InheritParentConfig

to match clang-tidy?

I will update it to InheritParentConfig.

[njames93]

clang/lib/Format/Format.cpp

3039

Yeah I know that this is double work, but I thought it only affects the case BasedOnStyle: File and keeps the "normal" way untouched.

If I do build a stack I would actually parse all .clang-format files up to the root directory and in the not BasedOnStyle: File case throw away the results, wouldn't I? The question is how often someone has a .clang-fomrat in one of his parent directories which is not used because it got overwritten.

I'm not saying start at the route directory and work down to the child. Still start at the child, but when you parse a configuration that has needs the parent, put that unparsed config into a stack, then carry on. At the end then you can join all those configurations

But I can do that.

Or is there an easy way to just check the BasedOnStyle value? As far as I understood the yaml code it parses the whole file into an internal structure and we only query this structure, right?

It should be possible, not an expert but I'm not sure it like being traversed multiple times normally, though a workaround should be feasible.

[HazardyKnusperkeks]

• Rebased
• Renamed to InhteritParentConfig
• Reworked to remove the recursion of getStyle
• Now supports the command line style options
• Test cases extended for the latter

[MyDeveloperDay]

What I can't easily tell from the tests is if you are overriding any styles defined in the parent with a local style.

clang/include/clang/Format/Format.h

57

I don't quite understand this last sentence

[HazardyKnusperkeks]

In D93844#2504376, @MyDeveloperDay wrote:

What I can't easily tell from the tests is if you are overriding any styles defined in the parent with a local style.

Yes I do, but I will try to make it clearer in the tests.

clang/include/clang/Format/Format.h

57

If I would use /// it would end up in the ClangFormatStyleOptions.rst. I only want to make clear it is no mistake that it only got // while all other members are documented with ///.

[HazardyKnusperkeks]

In D93844#2504388, @HazardyKnusperkeks wrote:

In D93844#2504376, @MyDeveloperDay wrote:

What I can't easily tell from the tests is if you are overriding any styles defined in the parent with a local style.

Yes I do, but I will try to make it clearer in the tests.

Okay after rechecking the code (it is a bit ago that I wrote it), what more do you need? I compare the parsed style against a base style (Google, to show that it’s not the default LLVM) modified with the values from the overwrite. Only for the last checks where I basically check the same over and over again, just trough different means I use a stored style.

[HazardyKnusperkeks]

Found and fixed the case when no BasedOnStyle apart from InheritParentConfig is used.

[HazardyKnusperkeks]

Rebased and Ping.

[curdeius]

clang/docs/ClangFormatStyleOptions.rst

160

Typo: fount -> found.

160

Why should it fallback to LLVM and not the fallback style?
It seems to me that it's a documentation problem.

[HazardyKnusperkeks]

clang/docs/ClangFormatStyleOptions.rst

160

Yap, fixed that.

[HazardyKnusperkeks]

Fixed documentation (and rebased).

[njames93]

As a follow up it may be wise to pass a diag handler to parseConfiguration as when we parse it a second time, we probably want to disregard any warnings (like unknown key) detected as they will have been printed on the first pass.

clang/lib/Format/Format.cpp

3036–3042

Nit: just use a for loop over a lambda.

3075

Nit: Add a void cast to silence unused warnings in release builds.

[HazardyKnusperkeks]

In D93844#2536354, @njames93 wrote:

As a follow up it may be wise to pass a diag handler to parseConfiguration as when we parse it a second time, we probably want to disregard any warnings (like unknown key) detected as they will have been printed on the first pass.

Will try to look into it.

clang/lib/Format/Format.cpp

3036–3042

Did not know about llvm::reverse.

[HazardyKnusperkeks]

Silence unused variable warnings in release and using llvm::reverse with range based for.

[zwliew]

clang/lib/Format/Format.cpp

3067

Is there a reason behind limiting the number of children configs to 1 in this case? When the fallback is not used, more than 1 children configs are allowed (line 3036).

Sorry for digging this up, I came across this seemingly arbitrary decision when working on some changes to https://reviews.llvm.org/D72326

[HazardyKnusperkeks]

clang/lib/Format/Format.cpp

3067

Yeah but it doesn't happen, there is at most only one .clang-format in the parent directory path which is found. So we assert on that and then don't need to loop over what is exactly one element big.

[zwliew]

clang/lib/Format/Format.cpp

3067

Thanks for the reply. However, I don't think that's true. Yes, it's only possible to find one .clang-format file in the first parent directory. But if it has BasedOnStyle: InheritParentConfig set, then we could find another .clang-format file in the "grandparent" directory. In this case, we'll have 2 elements in ChildFormatTextToApply, but only the very first one will actually be applied.

To illustrate, suppose we have the following file structure:

- .clang-format
- foo
  |- .clang-format
  |- input.cpp

Both .clang-format files have BasedOnStyle: InheritParentConfig set. When running clang-format --style=file foo/input.cpp, only the inner config is applied on the fallback style, while the outer config is ignored. When testing on a debug build, I encountered a crash due to the failed assert. When removing the assert, and using a loop to apply the configs, both the inner and outer configs are applied, which I believe is the expected behaviour.

[HazardyKnusperkeks]

clang/lib/Format/Format.cpp

3067

I can not explain it to you anymore, I would have to dig into it again. But if my tests are correct everything works. You can see that for Test 9.4 I create a .clang-format in /e/sub/sub/ which is based on /e/sub/.clang-format which again is based on /e/.clang-format.

The tests do not fail, the parsed style is as the three files suggest, and the assert holds. I'm pretty sure I have thought about that case, it happens in some kind of recursion.

[zwliew]

clang/lib/Format/Format.cpp

3067

I took a look through Test 9.4, and it doesn't test the case I'm thinking of, as it doesn't execute the fallback case.

In Test 9.4 the file structure is as follows:

- e/
  |- .clang-format (BasedOnStyle: Google) <-- outermost config
  |- sub/
    |- .clang-format (BasedOnStyle: `InheritParentConfig)
    |- sub/
      |- .clang-format (BasedOnStyle: InheritParentConfig)
      |- code.cpp

The reason it doesn't execute the fallback case is that the outermost config file doesn't have BasedOnStyle: InheritParentConfig set.

On the other hand, in the following directory structure, the fallback case would execute, the assert would fail (on debug builds), and only the innermost config would be applied (on release builds):

- e/
  |- .clang-format (BasedOnStyle: InheritParentConfig) <-- outermost config
  |- sub/
    |- .clang-format (BasedOnStyle: `InheritParentConfig)
    |- sub/
      |- .clang-format (BasedOnStyle: InheritParentConfig)
      |- code.cpp

In order to verify my claims, I think I should write a new test case for this. However, I do not know how to run test cases for only clang-format. Is there a way to do so? Thanks!

[zwliew]

clang/lib/Format/Format.cpp

3067

I added a new test case for the latter scenario and ran all the regression test cases with make check-clang. The test case does indeed fail due to the assertion failure. I've updated https://reviews.llvm.org/D72326 with the test case and the fix for it. Please have a look, thanks!

[HazardyKnusperkeks]

clang/lib/Format/Format.cpp

3067

In that case thanks for catching that.

But I think it should be a different patch for the fix. Do not put a bug fix with a new feature in one commit.
There should be a target FormatTests, which builds and runs only the tests for clang-format.

clang/docs/ClangFormatStyleOptions.rst

* ``WebKit``
     A style complying with `WebKit's style guide
     <https://www.webkit.org/coding/coding-style.html>`_
   * ``Microsoft``
     A style complying with `Microsoft's style guide
     <https://docs.microsoft.com/en-us/visualstudio/ide/editorconfig-code-style-settings-reference?view=vs-2017>`_
   * ``GNU``
     A style complying with the `GNU coding standards
     <https://www.gnu.org/prep/standards/standards.html>`_
+  * ``InheritParentConfig``
+    Not a real style, but allows to use the ``.clang-format`` file from the
+    parent directory (or its parent if there is none). If there is no parent
+    file found it falls back to the ``fallback`` style, and applies the changes
+    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** (``int``)
   The extra indent or outdent of access modifiers, e.g. ``public:``.
 
 **AlignAfterOpenBracket** (``BracketAlignmentStyle``)
   If ``true``, horizontally aligns arguments after an open bracket.

clang/docs/ReleaseNotes.rst

.. code-block:: c++
 
     // CaseSensitive
     #include "A/B.h"
     #include "A/b.h"
     #include "a/b.h"
     #include "B/A.h"
     #include "B/a.h"
 
+- ``BasedOnStyle: InheritParentConfig`` allows to use the ``.clang-format`` of
+  the parent directories to overwrite only parts of it.
+
 libclang
 --------
 
 - ...
 
 Static Analyzer
 ---------------
 

clang/include/clang/Format/Format.h

public:
   std::string message(int EV) const override;
 };
 const std::error_category &getParseCategory();
 std::error_code make_error_code(ParseError e);
 
 /// The ``FormatStyle`` is used to configure the formatting to follow
 /// 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:``.
   int AccessModifierOffset;
 
   /// Different styles for aligning after open brackets.
   enum BracketAlignmentStyle : unsigned char {
     /// Align parameters on the open bracket, e.g.:
     /// \code
     ///   someLongFunction(argument1,

clang/lib/Format/Format.cpp

static FormatStyle expandPresets(const FormatStyle &Style) {
   default:
     break;
   }
   return Expanded;
 }
 
 FormatStyle getLLVMStyle(FormatStyle::LanguageKind Language) {
   FormatStyle LLVMStyle;
+  LLVMStyle.InheritsParentConfig = false;
   LLVMStyle.Language = Language;
   LLVMStyle.AccessModifierOffset = -2;
   LLVMStyle.AlignEscapedNewlines = FormatStyle::ENAS_Right;
   LLVMStyle.AlignAfterOpenBracket = FormatStyle::BAS_Align;
   LLVMStyle.AlignOperands = FormatStyle::OAS_Align;
   LLVMStyle.AlignTrailingComments = true;
   LLVMStyle.AlignConsecutiveAssignments = FormatStyle::ACS_None;
   LLVMStyle.AlignConsecutiveBitFields = FormatStyle::ACS_None;
bool getPredefinedStyle(StringRef Name, FormatStyle::LanguageKind Language,
   } else if (Name.equals_lower("webkit")) {
     *Style = getWebKitStyle();
   } else if (Name.equals_lower("gnu")) {
     *Style = getGNUStyle();
   } else if (Name.equals_lower("microsoft")) {
     *Style = getMicrosoftStyle(Language);
   } else if (Name.equals_lower("none")) {
     *Style = getNoStyle();
+  } else if (Name.equals_lower("inheritparentconfig")) {
+    Style->InheritsParentConfig = true;
   } else {
     return false;
   }
 
   Style->Language = Language;
   return true;
 }
 
if (!FS) {
     FS = llvm::vfs::getRealFileSystem().get();
   }
   FormatStyle Style = getLLVMStyle(guessLanguage(FileName, Code));
 
   FormatStyle FallbackStyle = getNoStyle();
   if (!getPredefinedStyle(FallbackStyleName, Style.Language, &FallbackStyle))
     return make_string_error("Invalid fallback style \"" + FallbackStyleName);
 
+  llvm::SmallVector<std::unique_ptr<llvm::MemoryBuffer>, 1>
+      ChildFormatTextToApply;
+
   if (StyleName.startswith("{")) {
     // Parse YAML/JSON style from the command line.
-    if (std::error_code ec = parseConfiguration(
-            llvm::MemoryBufferRef(StyleName, "<command-line>"), &Style,
+    StringRef Source = "<command-line>";
+    if (std::error_code ec =
+            parseConfiguration(llvm::MemoryBufferRef(StyleName, Source), &Style,
                                AllowUnknownOptions))
       return make_string_error("Error parsing -style: " + ec.message());
+    if (Style.InheritsParentConfig)
+      ChildFormatTextToApply.emplace_back(
+          llvm::MemoryBuffer::getMemBuffer(StyleName, Source, false));
+    else
       return Style;
   }
 
-  if (!StyleName.equals_lower("file")) {
+  // If the style inherits the parent configuration it is a command line
+  // configuration, which wants to inherit, so we have to skip the check of the
+  // StyleName.
+  if (!Style.InheritsParentConfig && !StyleName.equals_lower("file")) {
     if (!getPredefinedStyle(StyleName, Style.Language, &Style))
       return make_string_error("Invalid value for -style");
+    if (!Style.InheritsParentConfig)
       return Style;
   }
 
+  // Reset possible inheritance
+  Style.InheritsParentConfig = false;
+
   // Look for .clang-format/_clang-format file in the file's parent directories.
   SmallString<128> UnsuitableConfigFiles;
   SmallString<128> Path(FileName);
   if (std::error_code EC = FS->makeAbsolute(Path))
     return make_string_error(EC.message());
 
   llvm::SmallVector<std::string, 2> FilesToLookFor;
   FilesToLookFor.push_back(".clang-format");
for (const auto &F : FilesToLookFor) {
             UnsuitableConfigFiles.append(ConfigFile);
             continue;
           }
           return make_string_error("Error reading " + ConfigFile + ": " +
                                    ec.message());
         }
         LLVM_DEBUG(llvm::dbgs()
                    << "Using configuration file " << ConfigFile << "\n");
+
+        if (!Style.InheritsParentConfig) {
+          if (ChildFormatTextToApply.empty())
             return Style;
+
+          LLVM_DEBUG(llvm::dbgs() << "Applying child configurations\n");
+
+          for (const auto& MemBuf : llvm::reverse(ChildFormatTextToApply)){
+            auto Ec = parseConfiguration(*MemBuf, &Style, AllowUnknownOptions);
+            // It was already correctly parsed.
+            assert(!Ec);
+            static_cast<void>(Ec);
+          }
+
+          return Style;
+        }
+
+        LLVM_DEBUG(llvm::dbgs() << "Inherits parent configuration\n");
+
+        // Reset inheritance of style
+        Style.InheritsParentConfig = false;
+
+        ChildFormatTextToApply.emplace_back(std::move(*Text));
+
+        // Breaking out of the inner loop, since we don't want to parse
+        // .clang-format AND _clang-format, if both exist. Then we continue the
+        // inner loop (parent directories) in search for the parent
+        // configuration.
+        break;
       }
     }
   }
   if (!UnsuitableConfigFiles.empty())
     return make_string_error("Configuration file(s) do(es) not support " +
                              getLanguageName(Style.Language) + ": " +
                              UnsuitableConfigFiles);
+
+  if (!ChildFormatTextToApply.empty()) {
+    assert(ChildFormatTextToApply.size() == 1);
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "Applying child configuration on fallback style\n");
+
+    auto Ec = parseConfiguration(*ChildFormatTextToApply.front(),
+                                 &FallbackStyle, AllowUnknownOptions);
+    // It was already correctly parsed.
+    assert(!Ec);
+    static_cast<void>(Ec);
+  }
+
   return FallbackStyle;
 }
 
 } // namespace format
 } // namespace clang

clang/unittests/Format/FormatTest.cpp

TEST(FormatStyle, GetStyleOfFile) {
 
   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
   ASSERT_TRUE((bool)Style7b);
 
   // Test 8: inferred per-language defaults apply.
   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
   ASSERT_TRUE((bool)StyleTd);
   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
+
+  // Test 9.1: overwriting a file style, when parent no file exists with no
+  // fallback style
+  ASSERT_TRUE(FS.addFile(
+      "/e/sub/.clang-format", 0,
+      llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
+                                       "ColumnLimit: 20")));
+  ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
+                         llvm::MemoryBuffer::getMemBuffer("int i;")));
+  auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, [] {
+    auto Style = getNoStyle();
+    Style.ColumnLimit = 20;
+    return Style;
+  }());
+
+  // Test 9.2: with LLVM fallback style
+  Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, [] {
+    auto Style = getLLVMStyle();
+    Style.ColumnLimit = 20;
+    return Style;
+  }());
+
+  // Test 9.3: with a parent file
+  ASSERT_TRUE(
+      FS.addFile("/e/.clang-format", 0,
+                 llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
+                                                  "UseTab: Always")));
+  Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, [] {
+    auto Style = getGoogleStyle();
+    Style.ColumnLimit = 20;
+    Style.UseTab = FormatStyle::UT_Always;
+    return Style;
+  }());
+
+  // Test 9.4: propagate more than one level
+  ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
+                         llvm::MemoryBuffer::getMemBuffer("int i;")));
+  ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
+                         llvm::MemoryBuffer::getMemBuffer(
+                             "BasedOnStyle: InheritParentConfig\n"
+                             "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
+  std::vector<std::string> NonDefaultWhiteSpaceMacros{"FOO", "BAR"};
+
+  const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
+    auto Style = getGoogleStyle();
+    Style.ColumnLimit = 20;
+    Style.UseTab = FormatStyle::UT_Always;
+    Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
+    return Style;
+  }();
+
+  ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
+  Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, SubSubStyle);
+
+  // Test 9.5: use InheritParentConfig as style name
+  Style9 =
+      getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, SubSubStyle);
+
+  // Test 9.6: use command line style with inheritance
+  Style9 = getStyle("{BasedOnStyle: InheritParentConfig}", "/e/sub/code.cpp",
+                    "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, SubSubStyle);
+
+  // Test 9.7: use command line style with inheritance and own config
+  Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
+                    "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
+                    "/e/sub/code.cpp", "none", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, SubSubStyle);
+
+  // Test 9.8: use inheritance from a file without BasedOnStyle
+  ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
+                         llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
+  ASSERT_TRUE(
+      FS.addFile("/e/withoutbase/sub/.clang-format", 0,
+                 llvm::MemoryBuffer::getMemBuffer(
+                     "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
+  // Make sure we do not use the fallback style
+  Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, [] {
+    auto Style = getLLVMStyle();
+    Style.ColumnLimit = 123;
+    return Style;
+  }());
+
+  Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
+  ASSERT_TRUE(static_cast<bool>(Style9));
+  ASSERT_EQ(*Style9, [] {
+    auto Style = getLLVMStyle();
+    Style.ColumnLimit = 123;
+    Style.IndentWidth = 7;
+    return Style;
+  }());
 }
 
 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
   // Column limit is 20.
   std::string Code = "Type *a =\n"
                      "    new Type();\n"
                      "g(iiiii, 0, jjjjj,\n"
                      "  0, kkkkk, 0, mm);\n"