/// Should be used for C, C++, ObjectiveC, ObjectiveC++.
LK_Cpp,
/// Should be used for JavaScript.
- LK_JavaScript
+ LK_JavaScript,
+ /// Should be used for Protocol Buffers
+ /// (https://developers.google.com/protocol-buffers/).
+ LK_Proto
};
/// \brief Language, this format style is targeted at.
/// http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml.
FormatStyle getGoogleJSStyle();
+/// \brief Returns a format style complying with Google's Protocol Buffer style:
+/// https://developers.google.com/protocol-buffers/docs/style.
+FormatStyle getGoogleProtoStyle();
+
/// \brief Returns a format style complying with Chromium's style guide:
/// http://www.chromium.org/developers/coding-style.
FormatStyle getChromiumStyle();
static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
+ IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
}
};
return GoogleJSStyle;
}
+FormatStyle getGoogleProtoStyle() {
+ FormatStyle GoogleProtoStyle = getGoogleStyle();
+ GoogleProtoStyle.Language = FormatStyle::LK_Proto;
+ GoogleProtoStyle.AllowShortFunctionsOnASingleLine = false;
+ return GoogleProtoStyle;
+}
+
FormatStyle getChromiumStyle() {
FormatStyle ChromiumStyle = getGoogleStyle();
ChromiumStyle.AllowAllParametersOfDeclarationOnNextLine = false;
} else if (Name.equals_lower("mozilla")) {
*Style = getMozillaStyle();
} else if (Name.equals_lower("google")) {
- *Style = Language == FormatStyle::LK_JavaScript ? getGoogleJSStyle()
- : getGoogleStyle();
+ switch (Language) {
+ case FormatStyle::LK_JavaScript:
+ *Style = getGoogleJSStyle();
+ break;
+ case FormatStyle::LK_Proto:
+ *Style = getGoogleProtoStyle();
+ break;
+ default:
+ *Style = getGoogleStyle();
+ }
} else if (Name.equals_lower("webkit")) {
*Style = getWebKitStyle();
} else if (Name.equals_lower("gnu")) {
return "C++";
case FormatStyle::LK_JavaScript:
return "JavaScript";
+ case FormatStyle::LK_Proto:
+ return "Proto";
default:
return "Unknown";
}
static FormatStyle::LanguageKind getLanguageByFileName(StringRef FileName) {
if (FileName.endswith_lower(".js")) {
return FormatStyle::LK_JavaScript;
+ } else if (FileName.endswith_lower(".proto") ||
+ FileName.endswith_lower(".protodevel")) {
+ return FormatStyle::LK_Proto;
}
return FormatStyle::LK_Cpp;
}
return 0;
if (Left.is(tok::comma))
return 1;
- if (Right.is(tok::l_square) && Right.Type != TT_ObjCMethodExpr)
- return 250;
-
+ if (Right.is(tok::l_square)) {
+ if (Style.Language == FormatStyle::LK_Proto)
+ return 1;
+ if (Right.Type != TT_ObjCMethodExpr)
+ return 250;
+ }
if (Right.Type == TT_StartOfName || Right.is(tok::kw_operator)) {
if (Line.First->is(tok::kw_for) && Right.PartOfMultiVariableDeclStmt)
return 3;
bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
const FormatToken &Left,
const FormatToken &Right) {
+ if (Style.Language == FormatStyle::LK_Proto) {
+ if (Right.is(tok::l_paren) && Left.TokenText == "returns")
+ return true;
+ }
if (Right.is(tok::hashhash))
return Left.is(tok::hash);
if (Left.isOneOf(tok::hashhash, tok::hash))
// deliberate choice and might have aligned the contents of the string
// literal accordingly. Thus, we try keep existing line breaks.
return Right.NewlinesBefore > 0;
+ } else if (Right.Previous->is(tok::l_brace) &&
+ Style.Language == FormatStyle::LK_Proto) {
+ // Don't enums onto single lines in protocol buffers.
+ return true;
}
return false;
}
add_clang_unittest(FormatTests
FormatTest.cpp
FormatTestJS.cpp
+ FormatTestProto.cpp
)
target_link_libraries(FormatTests
Style));
}
-TEST_F(FormatTest, FormatsProtocolBufferDefinitions) {
- // It seems that clang-format can format protocol buffer definitions
- // (see https://code.google.com/p/protobuf/).
- verifyFormat("message SomeMessage {\n"
- " required int32 field1 = 1;\n"
- " optional string field2 = 2 [default = \"2\"]\n"
- "}");
-}
-
TEST_F(FormatTest, FormatsLambdas) {
verifyFormat("int c = [b]() mutable {\n"
" return [&b] { return b++; }();\n"
--- /dev/null
+//===- unittest/Format/FormatTestProto.cpp --------------------------------===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#define DEBUG_TYPE "format-test"
+
+#include "FormatTestUtils.h"
+#include "clang/Format/Format.h"
+#include "llvm/Support/Debug.h"
+#include "gtest/gtest.h"
+
+namespace clang {
+namespace format {
+
+class FormatTestProto : public ::testing::Test {
+protected:
+ static std::string format(llvm::StringRef Code, unsigned Offset,
+ unsigned Length, const FormatStyle &Style) {
+ DEBUG(llvm::errs() << "---\n");
+ DEBUG(llvm::errs() << Code << "\n\n");
+ std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
+ tooling::Replacements Replaces = reformat(Style, Code, Ranges);
+ std::string Result = applyAllReplacements(Code, Replaces);
+ EXPECT_NE("", Result);
+ DEBUG(llvm::errs() << "\n" << Result << "\n\n");
+ return Result;
+ }
+
+ static std::string format(llvm::StringRef Code) {
+ return format(Code, 0, Code.size(), getGoogleProtoStyle());
+ }
+
+ static void verifyFormat(llvm::StringRef Code) {
+ EXPECT_EQ(Code.str(), format(test::messUp(Code)));
+ }
+};
+
+TEST_F(FormatTestProto, FormatsMessages) {
+ verifyFormat("message SomeMessage {\n"
+ " required int32 field1 = 1;\n"
+ "}");
+ verifyFormat("message SomeMessage {\n"
+ " required int32 field1 = 1;\n"
+ " optional string field2 = 2 [default = \"2\"]\n"
+ "}");
+}
+
+TEST_F(FormatTestProto, FormatsEnums) {
+ verifyFormat("enum Type {\n"
+ " UNKNOWN = 0;\n"
+ " TYPE_A = 1;\n"
+ " TYPE_B = 2;\n"
+ "};");
+}
+
+TEST_F(FormatTestProto, UnderstandsReturns) {
+ verifyFormat("rpc Search(SearchRequest) returns (SearchResponse);");
+}
+
+TEST_F(FormatTestProto, MessageFieldAttributes) {
+ verifyFormat("optional string test = 1 [default = \"test\"];");
+ verifyFormat("optional LongMessageType long_proto_field = 1\n"
+ " [default = REALLY_REALLY_LONG_CONSTANT_VALUE];");
+}
+
+} // end namespace tooling
+} // end namespace clang