#include "clang/Basic/SourceManager.h"
#include "clang/Lex/Lexer.h"
+#include <string>
+
namespace clang {
namespace format {
Annotation.SpaceRequiredBefore = false;
} else if (Annotation.Type == TokenAnnotation::TT_UnaryOperator) {
Annotation.SpaceRequiredBefore =
- Line.Tokens[i - 1].Tok.isNot(tok::l_paren);
+ Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&
+ Line.Tokens[i - 1].Tok.isNot(tok::l_square);
} else if (Line.Tokens[i - 1].Tok.is(tok::greater) &&
Line.Tokens[i].Tok.is(tok::greater)) {
- if (Annotation.Type == TokenAnnotation::TT_TemplateOpener &&
- Annotations[i - 1].Type == TokenAnnotation::TT_TemplateOpener)
- Annotation.SpaceRequiredBefore = Style.SplitTemplateClosingGreater;
- else if (Annotation.Type == TokenAnnotation::TT_TemplateCloser &&
+ if (Annotation.Type == TokenAnnotation::TT_TemplateCloser &&
Annotations[i - 1].Type == TokenAnnotation::TT_TemplateCloser)
Annotation.SpaceRequiredBefore = Style.SplitTemplateClosingGreater;
else
Annotations[i - 1].Type == TokenAnnotation::TT_TemplateCloser &&
Line.Tokens[i].Tok.is(tok::l_paren)) {
Annotation.SpaceRequiredBefore = false;
+ } else if (Line.Tokens[i].Tok.is(tok::less) &&
+ Line.Tokens[0].Tok.is(tok::hash)) {
+ Annotation.SpaceRequiredBefore = true;
} else {
Annotation.SpaceRequiredBefore =
spaceRequiredBetween(Line.Tokens[i - 1].Tok, Line.Tokens[i].Tok);
if (Tok.Tok.is(tok::star) || Tok.Tok.is(tok::amp))
Annotation.Type = determineStarAmpUsage(i);
- else if (Tok.Tok.is(tok::minus) && Line.Tokens[i - 1].Tok.is(tok::equal))
+ else if (isUnaryOperator(i))
Annotation.Type = TokenAnnotation::TT_UnaryOperator;
else if (isBinaryOperator(Line.Tokens[i]))
Annotation.Type = TokenAnnotation::TT_BinaryOperator;
}
}
+ bool isUnaryOperator(unsigned Index) {
+ const Token &Tok = Line.Tokens[Index].Tok;
+ if (Tok.isNot(tok::minus) && Tok.isNot(tok::plus))
+ return false;
+ const Token &PreviousTok = Line.Tokens[Index - 1].Tok;
+ if (PreviousTok.is(tok::equal) || PreviousTok.is(tok::l_paren) ||
+ PreviousTok.is(tok::comma) || PreviousTok.is(tok::l_square))
+ return true;
+ return Annotations[Index - 1].Type == TokenAnnotation::TT_BinaryOperator;
+ }
+
bool isBinaryOperator(const FormatToken &Tok) {
switch (Tok.Tok.getKind()) {
case tok::equal:
TEST_F(FormatTest, UndestandsUnaryOperators) {
verifyFormat("int a = -2;");
+ verifyFormat("f(-1, -2, -3);");
+ verifyFormat("a[-1] = 5;");
+ verifyFormat("int a = 5 + -2;");
}
TEST_F(FormatTest, UndestandsOverloadedOperators) {
// verifyFormat("int a = b * *c;");
}
+TEST_F(FormatTest, HandlesIncludeDirectives) {
+ EXPECT_EQ("#include <string>\n", format("#include <string>\n"));
+ EXPECT_EQ("#include \"a/b/string\"\n", format("#include \"a/b/string\"\n"));
+ EXPECT_EQ("#include \"string.h\"\n", format("#include \"string.h\"\n"));
+ EXPECT_EQ("#include \"string.h\"\n", format("#include \"string.h\"\n"));
+}
+
//TEST_F(FormatTest, IncorrectDerivedClass) {
// verifyFormat("public B {\n"
// "};");