From edbb656f2d48450731fca08cc1fa0709db0707d7 Mon Sep 17 00:00:00 2001 From: Marco Bubke Date: Thu, 20 Jul 2017 16:43:16 +0200 Subject: [PATCH] Clang: Add field prefix for HighlightingMark Change-Id: I6cbd091f65ed931fbc31707c09b832ad782de03f Reviewed-by: Nikolai Kosjar --- .../ipcsource/highlightingmark.cpp | 140 +++++++++--------- .../clangbackend/ipcsource/highlightingmark.h | 28 ++-- 2 files changed, 84 insertions(+), 84 deletions(-) diff --git a/src/tools/clangbackend/ipcsource/highlightingmark.cpp b/src/tools/clangbackend/ipcsource/highlightingmark.cpp index 58a8a298ce1..03dd894a694 100644 --- a/src/tools/clangbackend/ipcsource/highlightingmark.cpp +++ b/src/tools/clangbackend/ipcsource/highlightingmark.cpp @@ -43,69 +43,69 @@ HighlightingMark::HighlightingMark(const CXCursor &cxCursor, CXToken *cxToken, CXTranslationUnit cxTranslationUnit, std::vector ¤tOutputArgumentRanges) - : currentOutputArgumentRanges(¤tOutputArgumentRanges), - originalCursor(cxCursor) + : m_currentOutputArgumentRanges(¤tOutputArgumentRanges), + m_originalCursor(cxCursor) { const SourceRange sourceRange = clang_getTokenExtent(cxTranslationUnit, *cxToken); const auto start = sourceRange.start(); const auto end = sourceRange.end(); - line = start.line(); - column = start.column(); - offset = start.offset(); - length = end.offset() - start.offset(); - collectKinds(cxTranslationUnit, cxToken, originalCursor); + m_line = start.line(); + m_column = start.column(); + m_offset = start.offset(); + m_length = end.offset() - start.offset(); + collectKinds(cxTranslationUnit, cxToken, m_originalCursor); } HighlightingMark::HighlightingMark(uint line, uint column, uint length, HighlightingTypes types) - : line(line), - column(column), - length(length), - types(types) + : m_line(line), + m_column(column), + m_length(length), + m_types(types) { } HighlightingMark::HighlightingMark(uint line, uint column, uint length, HighlightingType type) - : line(line), - column(column), - length(length), - types(HighlightingTypes()) + : m_line(line), + m_column(column), + m_length(length), + m_types(HighlightingTypes()) { - types.mainHighlightingType = type; + m_types.mainHighlightingType = type; } bool HighlightingMark::hasInvalidMainType() const { - return types.mainHighlightingType == HighlightingType::Invalid; + return m_types.mainHighlightingType == HighlightingType::Invalid; } bool HighlightingMark::hasMainType(HighlightingType type) const { - return types.mainHighlightingType == type; + return m_types.mainHighlightingType == type; } bool HighlightingMark::hasMixinType(HighlightingType type) const { - auto found = std::find(types.mixinHighlightingTypes.begin(), - types.mixinHighlightingTypes.end(), + auto found = std::find(m_types.mixinHighlightingTypes.begin(), + m_types.mixinHighlightingTypes.end(), type); - return found != types.mixinHighlightingTypes.end(); + return found != m_types.mixinHighlightingTypes.end(); } bool HighlightingMark::hasOnlyType(HighlightingType type) const { - return types.mixinHighlightingTypes.size() == 0 && hasMainType(type); + return m_types.mixinHighlightingTypes.size() == 0 && hasMainType(type); } bool HighlightingMark::hasFunctionArguments() const { - return originalCursor.argumentCount() > 0; + return m_originalCursor.argumentCount() > 0; } HighlightingMark::operator HighlightingMarkContainer() const { - return HighlightingMarkContainer(line, column, length, types); + return HighlightingMarkContainer(m_line, m_column, m_length, m_types); } namespace { @@ -133,9 +133,9 @@ void HighlightingMark::memberReferenceKind(const Cursor &cursor) { if (cursor.isDynamicCall()) { if (isFinalFunction(cursor) || isFunctionInFinalClass(cursor)) - types.mainHighlightingType = HighlightingType::Function; + m_types.mainHighlightingType = HighlightingType::Function; else - types.mainHighlightingType = HighlightingType::VirtualFunction; + m_types.mainHighlightingType = HighlightingType::VirtualFunction; } else { identifierKind(cursor.referenced(), Recursion::RecursivePass); } @@ -152,47 +152,47 @@ void HighlightingMark::referencedTypeKind(const Cursor &cursor) case CXCursor_TypedefDecl: case CXCursor_TemplateTypeParameter: case CXCursor_TypeAliasDecl: - case CXCursor_EnumDecl: types.mainHighlightingType = HighlightingType::Type; break; - default: types.mainHighlightingType = HighlightingType::Invalid; break; + case CXCursor_EnumDecl: m_types.mainHighlightingType = HighlightingType::Type; break; + default: m_types.mainHighlightingType = HighlightingType::Invalid; break; } } void HighlightingMark::overloadedDeclRefKind(const Cursor &cursor) { - types.mainHighlightingType = HighlightingType::Function; + m_types.mainHighlightingType = HighlightingType::Function; // CLANG-UPGRADE-CHECK: Workaround still needed? // Workaround https://bugs.llvm.org//show_bug.cgi?id=33256 - SomeType in // "using N::SomeType" is mistakenly considered as a CXCursor_OverloadedDeclRef. if (cursor.overloadedDeclarationsCount() >= 1 && cursor.overloadedDeclaration(0).kind() != CXCursor_FunctionDecl) { - types.mainHighlightingType = HighlightingType::Type; + m_types.mainHighlightingType = HighlightingType::Type; } } void HighlightingMark::variableKind(const Cursor &cursor) { if (cursor.isLocalVariable()) - types.mainHighlightingType = HighlightingType::LocalVariable; + m_types.mainHighlightingType = HighlightingType::LocalVariable; else - types.mainHighlightingType = HighlightingType::GlobalVariable; + m_types.mainHighlightingType = HighlightingType::GlobalVariable; if (isOutputArgument()) - types.mixinHighlightingTypes.push_back(HighlightingType::OutputArgument); + m_types.mixinHighlightingTypes.push_back(HighlightingType::OutputArgument); } void HighlightingMark::fieldKind(const Cursor &) { - types.mainHighlightingType = HighlightingType::Field; + m_types.mainHighlightingType = HighlightingType::Field; if (isOutputArgument()) - types.mixinHighlightingTypes.push_back(HighlightingType::OutputArgument); + m_types.mixinHighlightingTypes.push_back(HighlightingType::OutputArgument); } bool HighlightingMark::isVirtualMethodDeclarationOrDefinition(const Cursor &cursor) const { return cursor.isVirtualMethod() - && (originalCursor.isDeclaration() || originalCursor.isDefinition()); + && (m_originalCursor.isDeclaration() || m_originalCursor.isDefinition()); } namespace { bool isNotFinalFunction(const Cursor &cursor) @@ -203,37 +203,37 @@ bool isNotFinalFunction(const Cursor &cursor) } bool HighlightingMark::isRealDynamicCall(const Cursor &cursor) const { - return originalCursor.isDynamicCall() && isNotFinalFunction(cursor); + return m_originalCursor.isDynamicCall() && isNotFinalFunction(cursor); } void HighlightingMark::addExtraTypeIfFirstPass(HighlightingType type, Recursion recursion) { if (recursion == Recursion::FirstPass) - types.mixinHighlightingTypes.push_back(type); + m_types.mixinHighlightingTypes.push_back(type); } bool HighlightingMark::isArgumentInCurrentOutputArgumentLocations() const { - auto originalSourceLocation = originalCursor.cxSourceLocation(); + auto originalSourceLocation = m_originalCursor.cxSourceLocation(); const auto isNotSameOutputArgument = [&] (const CXSourceRange ¤tSourceRange) { return originalSourceLocation.int_data >= currentSourceRange.begin_int_data && originalSourceLocation.int_data <= currentSourceRange.end_int_data; }; - auto found = std::find_if(currentOutputArgumentRanges->begin(), - currentOutputArgumentRanges->end(), - isNotSameOutputArgument); + auto found = std::find_if(m_currentOutputArgumentRanges->begin(), + m_currentOutputArgumentRanges->end(), + isNotSameOutputArgument); - bool isOutputArgument = found != currentOutputArgumentRanges->end(); + bool isOutputArgument = found != m_currentOutputArgumentRanges->end(); return isOutputArgument; } bool HighlightingMark::isOutputArgument() const { - if (currentOutputArgumentRanges->empty()) + if (m_currentOutputArgumentRanges->empty()) return false; return isArgumentInCurrentOutputArgumentLocations(); @@ -241,7 +241,7 @@ bool HighlightingMark::isOutputArgument() const void HighlightingMark::collectOutputArguments(const Cursor &cursor) { - cursor.collectOutputArgumentRangesTo(*currentOutputArgumentRanges); + cursor.collectOutputArgumentRangesTo(*m_currentOutputArgumentRanges); filterOutPreviousOutputArguments(); } @@ -262,22 +262,22 @@ uint getStart(CXSourceRange cxSourceRange) void HighlightingMark::filterOutPreviousOutputArguments() { auto isAfterLocation = [this] (CXSourceRange outputRange) { - return getStart(outputRange) > offset; + return getStart(outputRange) > m_offset; }; - auto precedingBegin = std::partition(currentOutputArgumentRanges->begin(), - currentOutputArgumentRanges->end(), + auto precedingBegin = std::partition(m_currentOutputArgumentRanges->begin(), + m_currentOutputArgumentRanges->end(), isAfterLocation); - currentOutputArgumentRanges->erase(precedingBegin, currentOutputArgumentRanges->end()); + m_currentOutputArgumentRanges->erase(precedingBegin, m_currentOutputArgumentRanges->end()); } void HighlightingMark::functionKind(const Cursor &cursor, Recursion recursion) { if (isRealDynamicCall(cursor) || isVirtualMethodDeclarationOrDefinition(cursor)) - types.mainHighlightingType = HighlightingType::VirtualFunction; + m_types.mainHighlightingType = HighlightingType::VirtualFunction; else - types.mainHighlightingType = HighlightingType::Function; + m_types.mainHighlightingType = HighlightingType::Function; addExtraTypeIfFirstPass(HighlightingType::Declaration, recursion); } @@ -291,7 +291,7 @@ void HighlightingMark::identifierKind(const Cursor &cursor, Recursion recursion) case CXCursor_CallExpr: case CXCursor_CXXMethod: functionKind(cursor, recursion); break; case CXCursor_NonTypeTemplateParameter: - case CXCursor_CompoundStmt: types.mainHighlightingType = HighlightingType::LocalVariable; break; + case CXCursor_CompoundStmt: m_types.mainHighlightingType = HighlightingType::LocalVariable; break; case CXCursor_ParmDecl: case CXCursor_VarDecl: variableKind(cursor); break; case CXCursor_DeclRefExpr: identifierKind(cursor.referenced(), Recursion::RecursivePass); break; @@ -303,7 +303,7 @@ void HighlightingMark::identifierKind(const Cursor &cursor, Recursion recursion) case CXCursor_ObjCClassMethodDecl: case CXCursor_ObjCInstanceMethodDecl: case CXCursor_ObjCSynthesizeDecl: - case CXCursor_ObjCDynamicDecl: types.mainHighlightingType = HighlightingType::Field; break; + case CXCursor_ObjCDynamicDecl: m_types.mainHighlightingType = HighlightingType::Field; break; case CXCursor_TypeRef: referencedTypeKind(cursor); break; case CXCursor_ClassDecl: case CXCursor_ClassTemplatePartialSpecialization: @@ -328,16 +328,16 @@ void HighlightingMark::identifierKind(const Cursor &cursor, Recursion recursion) case CXCursor_ObjCProtocolDecl: case CXCursor_ObjCProtocolRef: case CXCursor_ObjCClassRef: - case CXCursor_ObjCSuperClassRef: types.mainHighlightingType = HighlightingType::Type; break; + case CXCursor_ObjCSuperClassRef: m_types.mainHighlightingType = HighlightingType::Type; break; case CXCursor_OverloadedDeclRef: overloadedDeclRefKind(cursor); break; - case CXCursor_FunctionTemplate: types.mainHighlightingType = HighlightingType::Function; break; - case CXCursor_EnumConstantDecl: types.mainHighlightingType = HighlightingType::Enumeration; break; - case CXCursor_PreprocessingDirective: types.mainHighlightingType = HighlightingType::Preprocessor; break; - case CXCursor_MacroExpansion: types.mainHighlightingType = HighlightingType::PreprocessorExpansion; break; - case CXCursor_MacroDefinition: types.mainHighlightingType = HighlightingType::PreprocessorDefinition; break; - case CXCursor_InclusionDirective: types.mainHighlightingType = HighlightingType::StringLiteral; break; + case CXCursor_FunctionTemplate: m_types.mainHighlightingType = HighlightingType::Function; break; + case CXCursor_EnumConstantDecl: m_types.mainHighlightingType = HighlightingType::Enumeration; break; + case CXCursor_PreprocessingDirective: m_types.mainHighlightingType = HighlightingType::Preprocessor; break; + case CXCursor_MacroExpansion: m_types.mainHighlightingType = HighlightingType::PreprocessorExpansion; break; + case CXCursor_MacroDefinition: m_types.mainHighlightingType = HighlightingType::PreprocessorDefinition; break; + case CXCursor_InclusionDirective: m_types.mainHighlightingType = HighlightingType::StringLiteral; break; case CXCursor_LabelRef: - case CXCursor_LabelStmt: types.mainHighlightingType = HighlightingType::Label; break; + case CXCursor_LabelStmt: m_types.mainHighlightingType = HighlightingType::Label; break; default: break; } } @@ -422,23 +422,23 @@ void HighlightingMark::collectKinds(CXTranslationUnit cxTranslationUnit, { auto cxTokenKind = clang_getTokenKind(*cxToken); - types = HighlightingTypes(); + m_types = HighlightingTypes(); switch (cxTokenKind) { - case CXToken_Keyword: types.mainHighlightingType = highlightingTypeForKeyword(cxTranslationUnit, cxToken, originalCursor); break; - case CXToken_Punctuation: types.mainHighlightingType = punctuationKind(cursor); break; + case CXToken_Keyword: m_types.mainHighlightingType = highlightingTypeForKeyword(cxTranslationUnit, cxToken, m_originalCursor); break; + case CXToken_Punctuation: m_types.mainHighlightingType = punctuationKind(cursor); break; case CXToken_Identifier: identifierKind(cursor, Recursion::FirstPass); break; - case CXToken_Comment: types.mainHighlightingType = HighlightingType::Comment; break; - case CXToken_Literal: types.mainHighlightingType = literalKind(cursor); break; + case CXToken_Comment: m_types.mainHighlightingType = HighlightingType::Comment; break; + case CXToken_Literal: m_types.mainHighlightingType = literalKind(cursor); break; } } std::ostream &operator<<(std::ostream &os, const HighlightingMark& highlightingMark) { - os << "(type: " << highlightingMark.types << ", " - << " line: " << highlightingMark.line << ", " - << " column: " << highlightingMark.column << ", " - << " length: " << highlightingMark.length + os << "(type: " << highlightingMark.m_types << ", " + << " line: " << highlightingMark.m_line << ", " + << " column: " << highlightingMark.m_column << ", " + << " length: " << highlightingMark.m_length << ")"; return os; diff --git a/src/tools/clangbackend/ipcsource/highlightingmark.h b/src/tools/clangbackend/ipcsource/highlightingmark.h index 9d3f2f8feee..a749a5c9223 100644 --- a/src/tools/clangbackend/ipcsource/highlightingmark.h +++ b/src/tools/clangbackend/ipcsource/highlightingmark.h @@ -47,9 +47,9 @@ public: HighlightingMark(const CXCursor &cxCursor, CXToken *cxToken, CXTranslationUnit cxTranslationUnit, - std::vector ¤tOutputArgumentRanges); - HighlightingMark(uint line, uint column, uint length, HighlightingTypes types); - HighlightingMark(uint line, uint column, uint length, HighlightingType type); + std::vector &m_currentOutputArgumentRanges); + HighlightingMark(uint m_line, uint m_column, uint m_length, HighlightingTypes m_types); + HighlightingMark(uint m_line, uint m_column, uint m_length, HighlightingType type); bool hasInvalidMainType() const; bool hasMainType(HighlightingType type) const; @@ -80,22 +80,22 @@ private: friend std::ostream &operator<<(std::ostream &os, const HighlightingMark& highlightingMark); private: - std::vector *currentOutputArgumentRanges = nullptr; - Cursor originalCursor; - uint line; - uint column; - uint length; - uint offset = 0; - HighlightingTypes types; + std::vector *m_currentOutputArgumentRanges = nullptr; + Cursor m_originalCursor; + uint m_line; + uint m_column; + uint m_length; + uint m_offset = 0; + HighlightingTypes m_types; }; inline bool operator==(const HighlightingMark &first, const HighlightingMark &second) { - return first.line == second.line - && first.column == second.column - && first.length == second.length - && first.types == second.types; + return first.m_line == second.m_line + && first.m_column == second.m_column + && first.m_length == second.m_length + && first.m_types == second.m_types; } } // namespace ClangBackEnd