feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Highlighting: Add highlighting style for punctuation

Browse Source 
Currently only operators have their own style but not
punctuation tokens. Make possible to highlight both.

Task-number: QTCREATORBUG-20666
Change-Id: I9533e0f1bef65b86c4e4f5c9756571103584124b
Reviewed-by: Marco Bubke <marco.bubke@qt.io>
This commit is contained in:
Ivan Donchevskii
2018-08-22 17:25:12 +02:00
parent ccf2d848f4
commit 50e5aacb02
14 changed files with 93 additions and 79 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/libs/3rdparty/cplusplus/Token.h vendored
View File

@@ -332,6 +332,9 @@ public:
inline bool isOperator() const
{ return f.kind >= T_FIRST_OPERATOR && f.kind <= T_LAST_OPERATOR; }
inline bool isPunctuation() const
{ return f.kind >= T_FIRST_PUNCTUATION && f.kind <= T_LAST_PUNCTUATION; }
inline bool isPunctuationOrOperator() const
{ return f.kind >= T_FIRST_PUNCTUATION_OR_OPERATOR && f.kind <= T_LAST_PUNCTUATION_OR_OPERATOR; }

1
src/libs/clangsupport/clangsupport_global.h
View File

@@ -86,6 +86,7 @@ enum class HighlightingType : quint8
Preprocessor,
PreprocessorDefinition,
PreprocessorExpansion,
Punctuation,
Label,
Declaration,
FunctionDefinition,

1
src/libs/clangsupport/tokeninfocontainer.cpp
View File

@@ -53,6 +53,7 @@ static const char *highlightingTypeToCStringLiteral(HighlightingType type)
RETURN_TEXT_FOR_CASE(OutputArgument);
RETURN_TEXT_FOR_CASE(PreprocessorDefinition);
RETURN_TEXT_FOR_CASE(PreprocessorExpansion);
RETURN_TEXT_FOR_CASE(Punctuation);
RETURN_TEXT_FOR_CASE(Namespace);
RETURN_TEXT_FOR_CASE(Class);
RETURN_TEXT_FOR_CASE(Struct);

2
src/libs/clangsupport/tokeninfocontainer.h
View File

@@ -138,7 +138,7 @@ public:
return extraInfo.declaration
&& types.mainHighlightingType != HighlightingType::LocalVariable
&& ((types.mainHighlightingType == HighlightingType::Operator)
&& (types.mixinHighlightingTypes.contains(HighlightingType::Operator)
== extraInfo.token.startsWith("operator"));
}

2
src/plugins/clangcodemodel/clanghighlightingresultreporter.cpp
View File

@@ -62,6 +62,8 @@ TextEditor::TextStyle toTextStyle(ClangBackEnd::HighlightingType type)
case HighlightingType::PreprocessorDefinition:
case HighlightingType::PreprocessorExpansion:
return TextEditor::C_PREPROCESSOR;
case HighlightingType::Punctuation:
return TextEditor::C_PUNCTUATION;
case HighlightingType::Declaration:
return TextEditor::C_DECLARATION;
case HighlightingType::FunctionDefinition:

3
src/plugins/clangcodemodel/clangutils.cpp
View File

@@ -235,7 +235,8 @@ int clangColumn(const QTextBlock &line, int cppEditorColumn)
ClangBackEnd::StorageClass storageClass = extraInfo.storageClass;
if (mainType == ClangBackEnd::HighlightingType::VirtualFunction
|| mainType == ClangBackEnd::HighlightingType::Function
|| mainType == ClangBackEnd::HighlightingType::Operator) {
|| token.types.mixinHighlightingTypes.contains(
ClangBackEnd::HighlightingType::Operator)) {
if (storageClass != ClangBackEnd::StorageClass::Static) {
switch (access) {
case ClangBackEnd::AccessSpecifier::Public:

2
src/plugins/cppeditor/cpphighlighter.cpp
View File

@@ -203,6 +203,8 @@ void CppHighlighter::highlightBlock(const QString &text)
formatForCategory(C_PRIMITIVE_TYPE));
} else if (tk.isOperator()) {
setFormat(tk.utf16charsBegin(), tk.utf16chars(), formatForCategory(C_OPERATOR));
} else if (tk.isPunctuation()) {
setFormat(tk.utf16charsBegin(), tk.utf16chars(), formatForCategory(C_PUNCTUATION));
} else if (i == 0 && tokens.size() > 1 && tk.is(T_IDENTIFIER) && tokens.at(1).is(T_COLON)) {
setFormat(tk.utf16charsBegin(), tk.utf16chars(), formatForCategory(C_LABEL));
} else if (tk.is(T_IDENTIFIER)) {

1
src/plugins/texteditor/texteditorconstants.h
View File

@@ -60,6 +60,7 @@ enum TextStyle : quint8 {
C_PRIMITIVE_TYPE,
C_OPERATOR,
C_OVERLOADED_OPERATOR,
C_PUNCTUATION,
C_PREPROCESSOR,
C_LABEL,
C_COMMENT,

13
src/plugins/texteditor/texteditorsettings.cpp
View File

@@ -224,9 +224,16 @@ TextEditorSettings::TextEditorSettings()
formatDescr.emplace_back(C_KEYWORD, tr("Keyword"),
tr("Reserved keywords of the programming language except "
"keywords denoting primitive types."), Qt::darkYellow);
formatDescr.emplace_back(C_PUNCTUATION, tr("Punctuation"),
tr("Punctuation excluding operators."));
formatDescr.emplace_back(C_OPERATOR, tr("Operator"),
tr("Non user-defined language operators.\n"
"To style user-defined operators, use Overloaded Operator."));
"To style user-defined operators, use Overloaded Operator."),
Format::createMixinFormat());
formatDescr.emplace_back(C_OVERLOADED_OPERATOR,
tr("Overloaded Operators"),
tr("Calls and declarations of overloaded (user-defined) operators."),
Format::createMixinFormat());
formatDescr.emplace_back(C_PREPROCESSOR, tr("Preprocessor"),
tr("Preprocessor directives."), Qt::darkBlue);
formatDescr.emplace_back(C_LABEL, tr("Label"), tr("Labels for goto statements."),
@@ -313,10 +320,6 @@ TextEditorSettings::TextEditorSettings()
QColor(255, 190, 0),
QTextCharFormat::DotLine,
FormatDescription::ShowUnderlineControl);
formatDescr.emplace_back(C_OVERLOADED_OPERATOR,
tr("Overloaded Operators"),
tr("Calls and declarations of overloaded (user-defined) operators."),
Format::createMixinFormat());
Format declarationFormat = Format::createMixinFormat();
declarationFormat.setBold(true);
formatDescr.emplace_back(C_DECLARATION,

2
src/tools/clangbackend/source/fulltokeninfo.cpp
View File

@@ -243,7 +243,7 @@ void FullTokenInfo::overloadedOperatorKind()
{
TokenInfo::overloadedOperatorKind();
if (m_types.mixinHighlightingTypes.front() != HighlightingType::OverloadedOperator)
if (!m_types.mixinHighlightingTypes.contains(HighlightingType::OverloadedOperator))
return;
// Overloaded operator

8
src/tools/clangbackend/source/tokeninfo.cpp
View File

@@ -529,13 +529,13 @@ void TokenInfo::overloadedOperatorKind()
if (inOperatorDeclaration && !isTokenPartOfOperator(declarationCursor, m_cxToken))
return;
if (m_types.mainHighlightingType == HighlightingType::Invalid)
m_types.mainHighlightingType = HighlightingType::Operator;
m_types.mixinHighlightingTypes.push_back(HighlightingType::Operator);
m_types.mixinHighlightingTypes.push_back(HighlightingType::OverloadedOperator);
}
void TokenInfo::punctuationOrOperatorKind()
{
m_types.mainHighlightingType = HighlightingType::Punctuation;
auto kind = m_originalCursor.kind();
switch (kind) {
case CXCursor_CallExpr:
@@ -557,9 +557,7 @@ void TokenInfo::punctuationOrOperatorKind()
case CXCursor_BinaryOperator:
case CXCursor_CompoundAssignOperator:
case CXCursor_ConditionalOperator:
m_types.mainHighlightingType = HighlightingType::Operator;
break;
default:
m_types.mixinHighlightingTypes.push_back(HighlightingType::Operator);
break;
}

1
tests/unit/unittest/data/highlightingmarks.cpp
View File

@@ -672,4 +672,5 @@ int signalSlotTest() {
SIGNAL(something(QString));
SLOT(something(QString));
SIGNAL(something(QString (*func1)(QString)));
1 == 2;
}

1
tests/unit/unittest/gtest-creator-printing.cpp
View File

@@ -518,6 +518,7 @@ static const char *highlightingTypeToCStringLiteral(HighlightingType type)
RETURN_TEXT_FOR_CASE(PreprocessorDefinition);
RETURN_TEXT_FOR_CASE(PreprocessorExpansion);
RETURN_TEXT_FOR_CASE(PrimitiveType);
RETURN_TEXT_FOR_CASE(Punctuation);
RETURN_TEXT_FOR_CASE(Declaration);
RETURN_TEXT_FOR_CASE(Namespace);
RETURN_TEXT_FOR_CASE(Class);

132
tests/unit/unittest/tokenprocessor-test.cpp
View File

@@ -588,64 +588,64 @@ TEST_F(TokenProcessor, OverriddenPlusOperatorDeclaration)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(220, 67));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, CallToOverriddenPlusOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(224, 49));
ASSERT_THAT(infos[6], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[6], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, CallToOverriddenPlusAssignOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(226, 24));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, OverriddenStarOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(604, 26));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, OverriddenStarOperatorNonMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, IntegerCallToOverriddenBinaryOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(613, 9));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, FloatCallToOverriddenBinaryOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(614, 9));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, LeftShiftAssignmentOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(618, 32));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledLeftShiftAssignmentOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(629, 18));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::NumberLiteral));
}
@@ -653,48 +653,48 @@ TEST_F(TokenProcessor, FunctionCallOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(619, 29));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledFunctionCallOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(632, 16));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, AccessOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(620, 38));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledAccessOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(633, 16));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator));
}
TEST_F(TokenProcessor, NewOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(621, 39));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledNewOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(635, 34));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // = is not marked.
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // = is not marked.
// CLANG-UPGRADE-CHECK: Check if 'new' keyword usage cursor correctly returns referenced() cursor
// and uncomment this test in that case.
// ASSERT_THAT(infos[4], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // new
@@ -704,8 +704,8 @@ TEST_F(TokenProcessor, DeleteOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(622, 37));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // delete
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // delete
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledDeleteOperator)
@@ -716,24 +716,24 @@ TEST_F(TokenProcessor, CalledDeleteOperator)
// and uncomment this test in that case.
// ASSERT_THAT(infos[0], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // delete
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::LocalVariable));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Invalid)); // ; is a punctuation.
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Punctuation)); // ; is a punctuation.
}
TEST_F(TokenProcessor, NewArrayOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(623, 41));
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // new
ASSERT_THAT(infos[4], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // [
ASSERT_THAT(infos[5], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ]
ASSERT_THAT(infos[6], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // new
ASSERT_THAT(infos[4], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // [
ASSERT_THAT(infos[5], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ]
ASSERT_THAT(infos[6], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledNewArrayOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(637, 34));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // = is not marked.
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // = is not marked.
// CLANG-UPGRADE-CHECK: Check if 'new' keyword usage cursor correctly returns referenced() cursor
// and uncomment this test in that case.
// ASSERT_THAT(infos[4], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // new
@@ -743,10 +743,10 @@ TEST_F(TokenProcessor, DeleteArrayOperatorMemberDefinition)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(624, 39));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // delete
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // [
ASSERT_THAT(infos[4], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ]
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation.
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // delete
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // [
ASSERT_THAT(infos[4], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ]
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation.
}
TEST_F(TokenProcessor, CalledDeleteArrayOperator)
@@ -769,120 +769,120 @@ TEST_F(TokenProcessor, ParenthesisOperatorWithoutArguments)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(654, 25));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '('
ASSERT_THAT(infos[3], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ')'
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Invalid)); // second '(' is a punctuation
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '('
ASSERT_THAT(infos[3], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ')'
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Punctuation)); // second '(' is a punctuation
}
TEST_F(TokenProcessor, CalledParenthesisOperatorWithoutArguments)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(662, 14));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '('
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ')'
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '('
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // ')'
}
TEST_F(TokenProcessor, OperatorWithOnePunctuationTokenWithoutArguments)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(655, 25));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '*'
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '*'
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation
}
TEST_F(TokenProcessor, CalledOperatorWithOnePunctuationTokenWithoutArguments)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(663, 13));
ASSERT_THAT(infos[0], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '*'
ASSERT_THAT(infos[0], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '*'
}
TEST_F(TokenProcessor, EqualsOperatorOverload)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(656, 43));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Keyword, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '='
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid)); // ( is a punctuation
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Keyword, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // operator
ASSERT_THAT(infos[2], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '='
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation)); // ( is a punctuation
}
TEST_F(TokenProcessor, CalledEqualsOperatorOverload)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(664, 23));
ASSERT_THAT(infos[1], HasTwoTypes(HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '='
ASSERT_THAT(infos[1], HasThreeTypes(HighlightingType::Punctuation, HighlightingType::Operator, HighlightingType::OverloadedOperator)); // '='
}
TEST_F(TokenProcessor, LeftParenthesisIsAPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, SeparatingCommaIsAPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, RightParenthesisIsAPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[7], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[7], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, CurlyLeftParenthesisIsAPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[8], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[8], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, CurlyRightParenthesisIsAPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(607, 29));
ASSERT_THAT(infos[9], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[9], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, OperatorColon)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(668, 28));
ASSERT_THAT(infos[6], HasOnlyType(HighlightingType::Operator));
ASSERT_THAT(infos[6], HasTwoTypes(HighlightingType::Punctuation, HighlightingType::Operator));
}
TEST_F(TokenProcessor, PunctuationColon)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(133, 10));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, LessThanOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(668, 28));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Operator));
ASSERT_THAT(infos[2], HasTwoTypes(HighlightingType::Punctuation, HighlightingType::Operator));
}
TEST_F(TokenProcessor, LessThanPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(247, 19));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, GreaterThanPunctuation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(247, 19));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[4], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, Comment)
@@ -1136,13 +1136,13 @@ TEST_F(TokenProcessor, StaticCastIsKeyword)
ASSERT_THAT(infos[0], HasOnlyType(HighlightingType::Keyword));
}
TEST_F(TokenProcessor, StaticCastPunctationIsInvalid)
TEST_F(TokenProcessor, StaticCastPunctation)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(328, 64));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Punctuation));
ASSERT_THAT(infos[3], HasOnlyType(HighlightingType::Punctuation));
ASSERT_THAT(infos[5], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, TypeInReinterpretCast)
@@ -1240,14 +1240,14 @@ TEST_F(TokenProcessor, NoOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(389, 24));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[2], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, ScopeOperator)
{
const auto infos = translationUnit.tokenInfosInRange(sourceRange(400, 33));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Invalid));
ASSERT_THAT(infos[1], HasOnlyType(HighlightingType::Punctuation));
}
TEST_F(TokenProcessor, TemplateClassNamespace)
@@ -1652,7 +1652,7 @@ TEST_F(TokenProcessor, LexicalParentIndex)
const auto containers = translationUnit.fullTokenInfosInRange(
translationUnit.sourceRange(50, 1, 53, 3)).toTokenInfoContainers();
ASSERT_THAT(containers[3].extraInfo.lexicalParentIndex, 1);
ASSERT_THAT(containers[4].extraInfo.lexicalParentIndex, 1);
}
TEST_F(TokenProcessor, QtOldStyleSignal)