Clang: Add code completion for keyword snippets from clang

Change-Id: I91f7af74d811769424928bce1c586a30b5794d6f
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@theqtcompany.com>

src/plugins/clangcodemodel/completionchunkstotextconverter.cpp

@@ -30,15 +30,53 @@
 
 #include "completionchunkstotextconverter.h"
 
+#include <algorithm>
+#include <functional>
+
 namespace ClangCodeModel {
 namespace Internal {
 
 void CompletionChunksToTextConverter::parseChunks(const QVector<ClangBackEnd::CodeCompletionChunk> &codeCompletionChunks)
 {
     m_text.clear();
+    m_placeholderPositions.clear();
 
-    for (const auto &codeCompletionChunk : codeCompletionChunks)
-        parse(codeCompletionChunk);
+    m_codeCompletionChunks = codeCompletionChunks;
+
+    addExtraVerticalSpaceBetweenBraces();
+
+    std::for_each(m_codeCompletionChunks.cbegin(),
+                  m_codeCompletionChunks.cend(),
+                  [this] (const ClangBackEnd::CodeCompletionChunk &chunk)
+    {
+        parse(chunk);
+        m_previousCodeCompletionChunk = chunk;
+    });
+}
+
+void CompletionChunksToTextConverter::setAddPlaceHolderText(bool addPlaceHolderText)
+{
+    m_addPlaceHolderText = addPlaceHolderText;
+}
+
+void CompletionChunksToTextConverter::setAddPlaceHolderPositions(bool addPlaceHolderPositions)
+{
+    m_addPlaceHolderPositions = addPlaceHolderPositions;
+}
+
+void CompletionChunksToTextConverter::setAddResultType(bool addResultType)
+{
+    m_addResultType = addResultType;
+}
+
+void CompletionChunksToTextConverter::setAddSpaces(bool addSpaces)
+{
+    m_addSpaces = addSpaces;
+}
+
+void CompletionChunksToTextConverter::setAddExtraVerticalSpaceBetweenBraces(bool addExtraVerticalSpaceBetweenBraces)
+{
+    m_addExtraVerticalSpaceBetweenBraces = addExtraVerticalSpaceBetweenBraces;
 }
 
 const QString &CompletionChunksToTextConverter::text() const
@@ -46,7 +84,28 @@ const QString &CompletionChunksToTextConverter::text() const
     return m_text;
 }
 
-QString CompletionChunksToTextConverter::convert(const QVector<ClangBackEnd::CodeCompletionChunk> &codeCompletionChunks)
+const std::vector<int> &CompletionChunksToTextConverter::placeholderPositions() const
+{
+    return m_placeholderPositions;
+}
+
+bool CompletionChunksToTextConverter::hasPlaceholderPositions() const
+{
+    return m_placeholderPositions.size() > 0;
+}
+
+QString CompletionChunksToTextConverter::convertToFunctionSignature(const QVector<ClangBackEnd::CodeCompletionChunk> &codeCompletionChunks)
+{
+    CompletionChunksToTextConverter converter;
+    converter.setAddPlaceHolderText(true);
+    converter.setAddResultType(true);
+
+    converter.parseChunks(codeCompletionChunks);
+
+    return converter.text();
+}
+
+QString CompletionChunksToTextConverter::convertToName(const QVector<ClangBackEnd::CodeCompletionChunk> &codeCompletionChunks)
 {
     CompletionChunksToTextConverter converter;
 
@@ -62,17 +121,25 @@ void CompletionChunksToTextConverter::parse(const ClangBackEnd::CodeCompletionCh
     switch (codeCompletionChunk.kind()) {
         case CodeCompletionChunk::ResultType: parseResultType(codeCompletionChunk.text()); break;
         case CodeCompletionChunk::Optional: parseOptional(codeCompletionChunk); break;
+        case CodeCompletionChunk::Placeholder: parsePlaceHolder(codeCompletionChunk); break;
+        case CodeCompletionChunk::LeftParen: parseLeftParen(codeCompletionChunk); break;
+        case CodeCompletionChunk::LeftBrace: parseLeftBrace(codeCompletionChunk); break;
         default: parseText(codeCompletionChunk.text()); break;
     }
 }
 
 void CompletionChunksToTextConverter::parseResultType(const Utf8String &resultTypeText)
 {
-    m_text += resultTypeText.toString() + QChar(QChar::Space);
+    if (m_addResultType)
+        m_text += resultTypeText.toString() + QChar(QChar::Space);
 }
 
 void CompletionChunksToTextConverter::parseText(const Utf8String &text)
 {
+    if (m_addSpaces
+            && m_previousCodeCompletionChunk.kind() == ClangBackEnd::CodeCompletionChunk::RightBrace)
+        m_text += QChar(QChar::Space);
+
     m_text += text.toString();
 }
 
@@ -80,11 +147,84 @@ void CompletionChunksToTextConverter::parseOptional(const ClangBackEnd::CodeComp
 {
     m_text += QStringLiteral("<i>");
 
-    m_text += convert(optionalCodeCompletionChunk.optionalChunks());
+    m_text += convertToFunctionSignature(optionalCodeCompletionChunk.optionalChunks());
 
     m_text += QStringLiteral("</i>");
 }
 
+void CompletionChunksToTextConverter::parsePlaceHolder(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
+{
+    if (m_addPlaceHolderText)
+        m_text += codeCompletionChunk.text().toString();
+
+    if (m_addPlaceHolderPositions)
+        m_placeholderPositions.push_back(m_text.size());
+}
+
+void CompletionChunksToTextConverter::parseLeftParen(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
+{
+    if (m_addSpaces && m_previousCodeCompletionChunk.kind() != ClangBackEnd::CodeCompletionChunk::RightAngle)
+        m_text += QChar(QChar::Space);
+
+    m_text += codeCompletionChunk.text().toString();
+}
+
+void CompletionChunksToTextConverter::parseLeftBrace(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
+{
+    if (m_addSpaces)
+        m_text += QChar(QChar::Space);
+
+    m_text += codeCompletionChunk.text().toString();
+}
+
+void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces()
+{
+    if (m_addExtraVerticalSpaceBetweenBraces)
+        addExtraVerticalSpaceBetweenBraces(m_codeCompletionChunks.begin());
+}
+
+void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces(const QVector<ClangBackEnd::CodeCompletionChunk>::iterator &begin)
+{
+    using ClangBackEnd::CodeCompletionChunk;
+
+    const auto leftBraceCompare = [] (const CodeCompletionChunk &chunk) {
+        return chunk.kind() == CodeCompletionChunk::LeftBrace;
+    };
+
+    const auto rightBraceCompare = [] (const CodeCompletionChunk &chunk) {
+        return chunk.kind() == CodeCompletionChunk::RightBrace;
+    };
+
+    const auto verticalSpaceCompare = [] (const CodeCompletionChunk &chunk) {
+        return chunk.kind() == CodeCompletionChunk::VerticalSpace;
+    };
+
+    auto leftBrace = std::find_if(begin, m_codeCompletionChunks.end(), leftBraceCompare);
+
+    if (leftBrace != m_codeCompletionChunks.end()) {
+        auto rightBrace = std::find_if(leftBrace, m_codeCompletionChunks.end(), rightBraceCompare);
+
+        if (rightBrace != m_codeCompletionChunks.end()) {
+            auto verticalSpaceCount = std::count_if(leftBrace, rightBrace, verticalSpaceCompare);
+
+            if (verticalSpaceCount <= 1) {
+                auto distance = std::distance(leftBrace, rightBrace);
+                CodeCompletionChunk verticalSpaceChunck(CodeCompletionChunk::VerticalSpace,
+                                                        Utf8StringLiteral("\n"));
+                auto verticalSpace = m_codeCompletionChunks.insert(std::next(leftBrace),
+                                                                   verticalSpaceChunck);
+                std::advance(verticalSpace, distance);
+                rightBrace = verticalSpace;
+            }
+
+            auto begin = std::next(rightBrace);
+
+            if (begin != m_codeCompletionChunks.end())
+                addExtraVerticalSpaceBetweenBraces(begin);
+        }
+    }
+}
+
 } // namespace Internal
 } // namespace ClangCodeModel