Revert "Clang: Add possibility to "pgo-train" libclang with a batch file"

This reverts commit 07f4ae6227,
which broke compilation

clangbatchfileprocessor.cpp:170:27: error: ambiguous overload for
    'operator==' (operand types are 'const QChar' and 'char')

and only worked in QT_TEST=1 cases.

Change-Id: I089427359958221882cb4e4369c4b88d71779acf
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>

src/plugins/clangcodemodel/test/clangcodecompletion_test.cpp

@@ -25,7 +25,6 @@
 
 #include "clangcodecompletion_test.h"
 
-#include "../clangautomationutils.h"
 #include "../clangbackendipcintegration.h"
 #include "../clangcompletionassistinterface.h"
 #include "../clangmodelmanagersupport.h"
@@ -39,8 +38,12 @@
 #include <cpptools/cpptoolstestcase.h>
 #include <cpptools/modelmanagertesthelper.h>
 #include <cpptools/projectinfo.h>
+#include <texteditor/codeassist/assistinterface.h>
 #include <texteditor/codeassist/assistproposalitem.h>
+#include <texteditor/codeassist/completionassistprovider.h>
 #include <texteditor/codeassist/genericproposalmodel.h>
+#include <texteditor/codeassist/iassistprocessor.h>
+#include <texteditor/codeassist/iassistproposal.h>
 #include <texteditor/textdocument.h>
 #include <texteditor/texteditor.h>
 
@@ -177,6 +180,53 @@ void insertTextAtTopOfEditor(TextEditor::BaseTextEditor *editor, const QByteArra
     cs.apply(&textCursor);
 }
 
+class WaitForAsyncCompletions
+{
+public:
+    enum WaitResult { GotResults, GotInvalidResults, Timeout };
+    WaitResult wait(TextEditor::IAssistProcessor *processor,
+                    TextEditor::AssistInterface *assistInterface);
+
+    TextEditor::IAssistProposalModel *proposalModel;
+};
+
+WaitForAsyncCompletions::WaitResult WaitForAsyncCompletions::wait(
+        TextEditor::IAssistProcessor *processor,
+        TextEditor::AssistInterface *assistInterface)
+{
+    QTC_ASSERT(processor, return Timeout);
+    QTC_ASSERT(assistInterface, return Timeout);
+
+    bool gotResults = false;
+
+    processor->setAsyncCompletionAvailableHandler(
+                [this, &gotResults] (TextEditor::IAssistProposal *proposal) {
+        QTC_ASSERT(proposal, return);
+        proposalModel = proposal->model();
+        delete proposal;
+        gotResults = true;
+    });
+
+    // Are there any immediate results?
+    if (TextEditor::IAssistProposal *proposal = processor->perform(assistInterface)) {
+        delete processor;
+        proposalModel = proposal->model();
+        delete proposal;
+        QTC_ASSERT(proposalModel, return GotInvalidResults);
+        return GotResults;
+    }
+
+    // There are not any, so wait for async results.
+    QElapsedTimer timer; timer.start();
+    while (!gotResults) {
+        if (timer.elapsed() >= 30 * 1000)
+            return Timeout;
+        QCoreApplication::processEvents();
+    }
+
+    return proposalModel ? GotResults : GotInvalidResults;
+}
+
 class ChangeDocumentReloadSetting
 {
 public:
@@ -371,6 +421,51 @@ public:
     QString senderLog;
 };
 
+const CppTools::ProjectPartHeaderPaths toHeaderPaths(const QStringList &paths)
+{
+    using namespace CppTools;
+
+    ProjectPartHeaderPaths result;
+    foreach (const QString &path, paths)
+        result << ProjectPartHeaderPath(path, ProjectPartHeaderPath::IncludePath);
+    return result;
+}
+
+using ProposalModel = QSharedPointer<TextEditor::IAssistProposalModel>;
+
+ProposalModel completionResults(
+        TextEditor::BaseTextEditor *textEditor,
+        const QStringList &includePaths = QStringList())
+{
+    using namespace TextEditor;
+
+    TextEditorWidget *textEditorWidget = qobject_cast<TextEditorWidget *>(textEditor->widget());
+    QTC_ASSERT(textEditorWidget, return ProposalModel());
+    AssistInterface *assistInterface = textEditorWidget->createAssistInterface(
+                TextEditor::Completion, TextEditor::ExplicitlyInvoked);
+    QTC_ASSERT(assistInterface, return ProposalModel());
+    if (!includePaths.isEmpty()) {
+        auto clangAssistInterface = static_cast<ClangCompletionAssistInterface *>(assistInterface);
+        clangAssistInterface->setHeaderPaths(toHeaderPaths(includePaths));
+    }
+
+    CompletionAssistProvider *assistProvider
+            = textEditor->textDocument()->completionAssistProvider();
+    QTC_ASSERT(qobject_cast<ClangCompletionAssistProvider *>(assistProvider),
+               return ProposalModel());
+    QTC_ASSERT(assistProvider, return ProposalModel());
+    QTC_ASSERT(assistProvider->runType() == IAssistProvider::Asynchronous, return ProposalModel());
+
+    IAssistProcessor *processor = assistProvider->createProcessor();
+    QTC_ASSERT(processor, return ProposalModel());
+
+    WaitForAsyncCompletions waitForCompletions;
+    const WaitForAsyncCompletions::WaitResult result = waitForCompletions.wait(processor,
+                                                                               assistInterface);
+    QTC_ASSERT(result == WaitForAsyncCompletions::GotResults, return ProposalModel());
+    return QSharedPointer<TextEditor::IAssistProposalModel>(waitForCompletions.proposalModel);
+}
+
 class TestDocument
 {
 public:
@@ -594,7 +689,7 @@ public:
         if (!textToInsert.isEmpty())
             openEditor.editor()->insert(textToInsert);
 
-        proposal = completionResults(openEditor.editor(), includePaths, 15000);
+        proposal = completionResults(openEditor.editor(), includePaths);
     }
 
     ProposalModel proposal;