[clang-format] Adds a FormatStyleSet

[krasimir]

Summary

This patch adds a FormatStyleSet for storing per-language FormatStyles for the
purposes of formatting code blocks inside the main code.

[klimek]

lib/Format/Format.cpp

893

LanguageFound can't be true here.

903–907

This seems a bit backwards. I'd have expected us to build up a Style structure after parsing above, and then just copy that into the result in the end.

[krasimir]

lib/Format/Format.cpp

903–907

Do you mean to build up a StyleSet structure?

[krasimir]

• Address review comments

[krasimir]

• Remove accidentally created file

[krasimir]

• Address review comments

[klimek]

lib/Format/Format.cpp

920–921

Optional: I'd probably slightly re-structure the above to:

if (!LanguageFound) {
  if (Styles.empty() || Styles[0].Language != FS::LK_None) {
    return make_error_code(PE::Unsuitable);
  }
  ...
}

935

Should we rather check that a style that's added doesn't have its own Styles map? (I'd say you're not allowed to add a Style that was gotten into another StyleSet).

[krasimir]

• Address review comments

[bkramer]

include/clang/Format/Format.h

1700

Why unique_ptr?

1706

Document what happens if the Style for this language is in the set already.

lib/Format/Format.cpp

918

std::move

940

You can std::move Style here, it's passed by value.

940

Can Style.Language ever be LK_None? Does that even make sense?

[krasimir]

• Address review comments

[krasimir]

• Remove accidentally added file

[bkramer]

lg

include/clang/Format/Format.h

return AccessModifierOffset == R.AccessModifierOffset &&
            SpacesInAngles == R.SpacesInAngles &&
            SpacesInContainerLiterals == R.SpacesInContainerLiterals &&
            SpacesInCStyleCastParentheses == R.SpacesInCStyleCastParentheses &&
            SpacesInParentheses == R.SpacesInParentheses &&
            SpacesInSquareBrackets == R.SpacesInSquareBrackets &&
            Standard == R.Standard && TabWidth == R.TabWidth &&
            UseTab == R.UseTab;
   }
+
+  llvm::Optional<FormatStyle> GetLanguageStyle(LanguageKind Language) const;
+  void AddLanguageStyle(const FormatStyle& Style);
+
+ private:
+   // Stores per-language styles. A FormatStyle instance inside has an empty
+   // StyleSet. A FormatStyle instance returned by the Get method has its
+   // StyleSet set to a copy of the originating StyleSet, effectively keeping
+   // the internal representation of that StyleSet alive.
+   //
+   // The memory management and ownership reminds of a birds nest: chicks
+   // leaving the nest take photos of the nest with them.
+   struct FormatStyleSet {
+     typedef std::map<FormatStyle::LanguageKind,
+                      std::unique_ptr<const FormatStyle>>
+         MapType;
+     llvm::Optional<FormatStyle> Get(FormatStyle::LanguageKind Language) const;
+     void Add(FormatStyle Style);
+   private:
+     std::shared_ptr<MapType> Styles;
+   };
+
+   FormatStyleSet StyleSet;
 };
 
 /// \brief Returns a format style complying with the LLVM coding standards:
 /// http://llvm.org/docs/CodingStandards.html.
 FormatStyle getLLVMStyle();
 
 /// \brief Returns a format style complying with one of Google's style guides:
 /// http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml.

lib/Format/Format.cpp

for (unsigned j = 0; j < i; ++j) {
               << " and " << i << "\n");
         return make_error_code(ParseError::Error);
       }
     }
   }
   // Look for a suitable configuration starting from the end, so we can
   // find the configuration for the specific language first, and the default
   // configuration (which can only be at slot 0) after it.
+  bool LanguageFound = false;
   for (int i = Styles.size() - 1; i >= 0; --i) {
-    if (Styles[i].Language == Language ||
-        Styles[i].Language == FormatStyle::LK_None) {
+    if (!LanguageFound && (Styles[i].Language == Language ||
+                           Styles[i].Language == FormatStyle::LK_None)) {
       *Style = Styles[i];
       Style->Language = Language;
-      return make_error_code(ParseError::Success);
+      LanguageFound = true;
+      break;
     }
   }
+  if (!LanguageFound)
     return make_error_code(ParseError::Unsuitable);
+  for (int i = Styles.size() - 1; i >= 0; --i) {
+    if (Styles[i].Language != FormatStyle::LK_None) {
+      Style->AddLanguageStyle(Styles[i]);
+    }
+  }
+  return make_error_code(ParseError::Success);
 }
 
 std::string configurationAsText(const FormatStyle &Style) {
   std::string Text;
   llvm::raw_string_ostream Stream(Text);
   llvm::yaml::Output Output(Stream);
   // We use the same mapping method for input and output, so we need a non-const
   // reference here.
   FormatStyle NonConstStyle = expandPresets(Style);
   Output << NonConstStyle;
   return Stream.str();
 }
 
+llvm::Optional<FormatStyle>
+FormatStyle::FormatStyleSet::Get(FormatStyle::LanguageKind Language) const {
+  if (!Styles)
+    return None;
+  auto It = Styles->find(Language);
+  if (It == Styles->end())
+    return None;
+  FormatStyle Style = *It->second;
+  Style.StyleSet = *this;
+  return Style;
+}
+
+void FormatStyle::FormatStyleSet::Add(FormatStyle Style) {
+  Style.StyleSet.Styles.reset();
+  if (!Styles)
+    Styles = std::make_shared<MapType>();
+  (*Styles)[Style.Language].reset(new FormatStyle(Style));
+}
+
+llvm::Optional<FormatStyle>
+FormatStyle::GetLanguageStyle(FormatStyle::LanguageKind Language) const {
+  return StyleSet.Get(Language);
+}
+
+void FormatStyle::AddLanguageStyle(const FormatStyle& Style) {
+  StyleSet.Add(Style);
+}
+
 namespace {
 
 class JavaScriptRequoter : public TokenAnalyzer {
 public:
   JavaScriptRequoter(const Environment &Env, const FormatStyle &Style)
       : TokenAnalyzer(Env, Style) {}
 
   std::pair<tooling::Replacements, unsigned>