Clang: Fix emphasizing current parameter in function signature tooltip

...when completing function calls.

Task-number: QTCREATORBUG-15108
Change-Id: If55effe117774f3ec5debb03a9c7889981ea27d2
Reviewed-by: Marco Bubke <marco.bubke@theqtcompany.com>

src/plugins/clangcodemodel/clangcompletionchunkstotextconverter.cpp

@@ -81,9 +81,9 @@ void CompletionChunksToTextConverter::setAddExtraVerticalSpaceBetweenBraces(
     m_addExtraVerticalSpaceBetweenBraces = addExtraVerticalSpaceBetweenBraces;
 }
 
-void CompletionChunksToTextConverter::setAddHtmlTags(bool addHtmlTags)
+void CompletionChunksToTextConverter::setEmphasizeOptional(bool emphasizeOptional)
 {
-    m_addHtmlTags = addHtmlTags;
+    m_emphasizeOptional = emphasizeOptional;
 }
 
 void CompletionChunksToTextConverter::setAddOptional(bool addOptional)
@@ -91,6 +91,11 @@ void CompletionChunksToTextConverter::setAddOptional(bool addOptional)
     m_addOptional = addOptional;
 }
 
+void CompletionChunksToTextConverter::setPlaceHolderToEmphasize(int placeHolderNumber)
+{
+    m_placeHolderPositionToEmphasize = placeHolderNumber;
+}
+
 const QString &CompletionChunksToTextConverter::text() const
 {
     return m_text;
@@ -107,12 +112,18 @@ bool CompletionChunksToTextConverter::hasPlaceholderPositions() const
 }
 
 QString CompletionChunksToTextConverter::convertToFunctionSignature(
-        const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks)
+        const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks,
+        int parameterToEmphasize)
 {
     CompletionChunksToTextConverter converter;
     converter.setAddPlaceHolderText(true);
     converter.setAddResultType(true);
+
     converter.setAddOptional(true);
+    converter.setEmphasizeOptional(true);
+
+    converter.setAddPlaceHolderPositions(true);
+    converter.setPlaceHolderToEmphasize(parameterToEmphasize);
 
     converter.parseChunks(codeCompletionChunks);
 
@@ -137,7 +148,7 @@ QString CompletionChunksToTextConverter::convertToToolTip(
     converter.setAddSpaces(true);
     converter.setAddExtraVerticalSpaceBetweenBraces(true);
     converter.setAddOptional(true);
-    converter.setAddHtmlTags(true);
+    converter.setEmphasizeOptional(true);
     converter.setAddResultType(true);
 
     converter.parseChunks(codeCompletionChunks);
@@ -188,7 +199,7 @@ void CompletionChunksToTextConverter::wrapInCursiveTagIfOptional(
         const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
 {
     if (m_addOptional) {
-        if (m_addHtmlTags) {
+        if (m_emphasizeOptional) {
             if (!m_previousCodeCompletionChunk.isOptional() && codeCompletionChunk.isOptional())
                 m_text += QStringLiteral("<i>");
             else if (m_previousCodeCompletionChunk.isOptional() && !codeCompletionChunk.isOptional())
@@ -201,7 +212,7 @@ void CompletionChunksToTextConverter::parsePlaceHolder(
         const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk)
 {
     if (m_addPlaceHolderText)
-        m_text += codeCompletionChunk.text().toString();
+        appendText(codeCompletionChunk.text().toString(), emphasizeCurrentPlaceHolder());
 
     if (m_addPlaceHolderPositions)
         m_placeholderPositions.push_back(m_text.size());
@@ -274,6 +285,24 @@ void CompletionChunksToTextConverter::addExtraVerticalSpaceBetweenBraces(
     }
 }
 
+bool CompletionChunksToTextConverter::emphasizeCurrentPlaceHolder() const
+{
+    if (m_addPlaceHolderPositions) {
+        const uint currentPlaceHolderPosition = m_placeholderPositions.size() + 1;
+        return uint(m_placeHolderPositionToEmphasize) == currentPlaceHolderPosition;
+    }
+
+    return false;
+}
+
+void CompletionChunksToTextConverter::appendText(const QString &text, bool boldFormat)
+{
+    if (boldFormat)
+        m_text += QStringLiteral("<b>") + text + QStringLiteral("</b>");
+    else
+        m_text += text;
+}
+
 bool CompletionChunksToTextConverter::canAddSpace() const
 {
     return m_addSpaces

src/plugins/clangcodemodel/clangcompletionchunkstotextconverter.h

@@ -52,14 +52,16 @@ public:
     void setAddResultType(bool addResultType);
     void setAddSpaces(bool addSpaces);
     void setAddExtraVerticalSpaceBetweenBraces(bool addExtraVerticalSpaceBetweenBraces);
-    void setAddHtmlTags(bool addHtmlTags);
+    void setEmphasizeOptional(bool emphasizeOptional);
     void setAddOptional(bool addOptional);
+    void setPlaceHolderToEmphasize(int placeHolderNumber);
 
     const QString &text() const;
     const std::vector<int> &placeholderPositions() const;
     bool hasPlaceholderPositions() const;
 
-    static QString convertToFunctionSignature(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
+    static QString convertToFunctionSignature(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks,
+                                              int parameterToEmphasize = -1);
     static QString convertToName(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
     static QString convertToToolTip(const ClangBackEnd::CodeCompletionChunks &codeCompletionChunks);
 private:
@@ -74,20 +76,24 @@ private:
     void addExtraVerticalSpaceBetweenBraces();
     void addExtraVerticalSpaceBetweenBraces(const ClangBackEnd::CodeCompletionChunks::iterator &);
 
+    void appendText(const QString &text, bool boldFormat = false);
     bool canAddSpace() const;
     bool isNotOptionalOrAddOptionals(const ClangBackEnd::CodeCompletionChunk &codeCompletionChunk) const;
 
+    bool emphasizeCurrentPlaceHolder() const;
+
 private:
     std::vector<int> m_placeholderPositions;
     ClangBackEnd::CodeCompletionChunks m_codeCompletionChunks;
     ClangBackEnd::CodeCompletionChunk m_previousCodeCompletionChunk;
     QString m_text;
+    int m_placeHolderPositionToEmphasize = -1;
     bool m_addPlaceHolderText = false;
     bool m_addPlaceHolderPositions = false;
     bool m_addResultType = false;
     bool m_addSpaces = false;
     bool m_addExtraVerticalSpaceBetweenBraces = false;
-    bool m_addHtmlTags = false;
+    bool m_emphasizeOptional = false;
     bool m_addOptional = false;
 };
 

src/plugins/clangcodemodel/clangfunctionhintmodel.cpp

@@ -56,27 +56,11 @@ int ClangFunctionHintModel::size() const
 
 QString ClangFunctionHintModel::text(int index) const
 {
-#if 0
+    const ClangBackEnd::CodeCompletionChunks chunks = m_functionSymbols.at(index).chunks();
-    // TODO: add the boldening to the result
+    const QString signatureWithEmphasizedCurrentParameter
-    Overview overview;
+        = CompletionChunksToTextConverter::convertToFunctionSignature(chunks, m_currentArg + 1);
-    overview.setShowReturnTypes(true);
-    overview.setShowArgumentNames(true);
-    overview.setMarkedArgument(m_currentArg + 1);
-    Function *f = m_functionSymbols.at(index);
 
-    const QString prettyMethod = overview(f->type(), f->name());
+    return signatureWithEmphasizedCurrentParameter;
-    const int begin = overview.markedArgumentBegin();
-    const int end = overview.markedArgumentEnd();
-
-    QString hintText;
-    hintText += prettyMethod.left(begin).toHtmlEscaped());
-    hintText += "<b>";
-    hintText += prettyMethod.mid(begin, end - begin).toHtmlEscaped());
-    hintText += "</b>";
-    hintText += prettyMethod.mid(end).toHtmlEscaped());
-    return hintText;
-#endif
-    return CompletionChunksToTextConverter::convertToFunctionSignature(m_functionSymbols.at(index).chunks());
 }
 
 int ClangFunctionHintModel::activeArgument(const QString &prefix) const

src/plugins/clangcodemodel/test/clangcodecompletion_test.cpp

@@ -962,8 +962,8 @@ void ClangCodeCompletionTest::testCompleteFunctions()
     QVERIFY(hasItem(t.proposal, "void f()"));
     QVERIFY(hasItem(t.proposal, "void f(int a)"));
     QVERIFY(hasItem(t.proposal, "void f(const QString &s)"));
-    QVERIFY(hasItem(t.proposal, "void f(char c, int optional)")); // TODO: No default argument?
+    QVERIFY(hasItem(t.proposal, "void f(char c<i>, int optional</i>)")); // TODO: No default argument?
-    QVERIFY(hasItem(t.proposal, "void f(char c, int optional1, int optional2)")); // TODO: No default argument?
+    QVERIFY(hasItem(t.proposal, "void f(char c<i>, int optional1, int optional2</i>)")); // TODO: No default argument?
     QVERIFY(hasItem(t.proposal, "void f(const TType<QString> *t)"));
     QVERIFY(hasItem(t.proposal, "TType<QString> f(bool)"));
 }

tests/unit/unittest/completionchunkstotextconvertertest.cpp

@@ -119,6 +119,72 @@ TEST_F(CompletionChunksToTextConverter, ConvertFunctionWithParameters)
     ASSERT_THAT(converter.text(), QStringLiteral("int Function(char x)"));
 }
 
+TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneArgument)
+{
+    CodeCompletionChunks completionChunks({integerResultType,
+                                           functionName,
+                                           leftParen,
+                                           functionArgumentX,
+                                           rightParen});
+
+    using ClangCodeModel::Internal::CompletionChunksToTextConverter;
+
+    ASSERT_THAT(converter.convertToFunctionSignature(completionChunks),
+                QStringLiteral("int Function(char x)"));
+}
+
+TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneParameterThatIsActive)
+{
+    CodeCompletionChunks completionChunks({integerResultType,
+                                           functionName,
+                                           leftParen,
+                                            functionArgumentX,
+                                           rightParen});
+
+    ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 1),
+                QStringLiteral("int Function(<b>char x</b>)"));
+}
+
+TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithOneParameterAndInInvalidActiveParameter)
+{
+    CodeCompletionChunks completionChunks({integerResultType,
+                                           functionName,
+                                           leftParen,
+                                            functionArgumentX,
+                                           rightParen});
+
+    ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, -1),
+                QStringLiteral("int Function(char x)"));
+}
+
+TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTwoParametersWhereOneIsActive)
+{
+    CodeCompletionChunks completionChunks({integerResultType,
+                                           functionName,
+                                           leftParen,
+                                            functionArgumentX,
+                                            comma,
+                                            functionArgumentY,
+                                           rightParen});
+
+    ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 2),
+                QStringLiteral("int Function(char x, <b>int y</b>)"));
+}
+
+TEST_F(CompletionChunksToTextConverter, ConvertToFunctionSignatureWithTwoParametersWhereOneIsOptionalAndActive)
+{
+    CodeCompletionChunks completionChunks({integerResultType,
+                                           functionName,
+                                           leftParen,
+                                            functionArgumentX,
+                                            optionalComma,
+                                            optionalFunctionArgumentY,
+                                           rightParen});
+
+    ASSERT_THAT(converter.convertToFunctionSignature(completionChunks, 2),
+                QStringLiteral("int Function(char x<i>, <b>int y</b></i>)"));
+}
+
 TEST_F(CompletionChunksToTextConverter, ConvertFunctionWithOptionalParameter)
 {
     CodeCompletionChunks completionChunks({integerResultType,