CppEditor: Simplify VirtualFunctionAssist{Processor,Provider}

...by extracting parameters to a dedicated struct.

Change-Id: I2f3b83cbc62a8b4a91b44b3a729d0f0c578b53f2
Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>

src/plugins/cppeditor/cppfollowsymbolundercursor.cpp

@@ -556,11 +556,17 @@ BaseTextEditorWidget::Link FollowSymbolUnderCursor::findLink(const QTextCursor &
                 Class *klass = symbolFinder->findMatchingClassDeclaration(function, snapshot);
                 QTC_CHECK(klass);
 
-                if (m_virtualFunctionAssistProvider->configure(klass, function, snapshot,
+                VirtualFunctionAssistProvider::Parameters params;
-                                                               inNextSplit)) {
+                params.startClass = klass;
+                params.function = function;
+                params.snapshot = snapshot;
+                params.openInNextSplit = inNextSplit;
+
+                if (m_virtualFunctionAssistProvider->configure(params)) {
                     m_widget->invokeAssist(TextEditor::FollowSymbol,
                                            m_virtualFunctionAssistProvider);
                 }
+
                 return Link();
             }
 

src/plugins/cppeditor/cppvirtualfunctionassistprovider.cpp

@@ -109,16 +109,14 @@ private:
 class VirtualFunctionsAssistProcessor : public IAssistProcessor
 {
 public:
-    VirtualFunctionsAssistProcessor(const VirtualFunctionAssistProvider *provider)
+    VirtualFunctionsAssistProcessor(const VirtualFunctionAssistProvider::Parameters &params)
-        : m_startClass(provider->startClass())
+        : m_params(params)
-        , m_function(provider->function())
-        , m_snapshot(provider->snapshot())
-        , m_openInNextSplit(provider->openInNextSplit())
     {}
 
-    IAssistProposal *immediateProposal(const TextEditor::IAssistInterface *interface)
+    IAssistProposal *immediateProposal(const TextEditor::IAssistInterface *assistInterface)
     {
-        QTC_ASSERT(m_function, return 0);
+        QTC_ASSERT(assistInterface, return 0);
+        QTC_ASSERT(m_params.function, return 0);
 
         BasicProposalItem *hintItem = new VirtualFunctionProposalItem(CPPEditorWidget::Link());
         hintItem->setText(QCoreApplication::translate("VirtualFunctionsAssistProcessor",
@@ -126,24 +124,22 @@ public:
         hintItem->setOrder(-1000);
 
         QList<BasicProposalItem *> items;
-        items << itemFromSymbol(maybeDefinitionFor(m_function));
+        items << itemFromSymbol(maybeDefinitionFor(m_params.function));
         items << hintItem;
-        return new VirtualFunctionProposal(interface->position(),
+        return new VirtualFunctionProposal(assistInterface->position(),
                                            new BasicProposalItemListModel(items),
-                                           m_openInNextSplit);
+                                           m_params.openInNextSplit);
     }
 
-    IAssistProposal *perform(const IAssistInterface *interface)
+    IAssistProposal *perform(const IAssistInterface *assistInterface)
     {
-        if (!interface)
+        QTC_ASSERT(assistInterface, return 0);
-            return 0;
+        QTC_ASSERT(m_params.startClass, return 0);
+        QTC_ASSERT(m_params.function, return 0);
+        QTC_ASSERT(!m_params.snapshot.isEmpty(), return 0);
 
-        QTC_ASSERT(m_startClass, return 0);
+        const QList<Symbol *> overrides
-        QTC_ASSERT(m_function, return 0);
+            = FunctionHelper::overrides(m_params.startClass, m_params.function, m_params.snapshot);
-        QTC_ASSERT(!m_snapshot.isEmpty(), return 0);
-
-        const QList<Symbol *> overrides = FunctionHelper::overrides(m_startClass, m_function,
-                                                                    m_snapshot);
         if (overrides.isEmpty())
             return 0;
 
@@ -152,15 +148,15 @@ public:
             items << itemFromSymbol(maybeDefinitionFor(symbol));
         items.first()->setOrder(1000); // Ensure top position for function of static type
 
-        return new VirtualFunctionProposal(interface->position(),
+        return new VirtualFunctionProposal(assistInterface->position(),
                                            new BasicProposalItemListModel(items),
-                                           m_openInNextSplit);
+                                           m_params.openInNextSplit);
     }
 
 private:
     Symbol *maybeDefinitionFor(Symbol *symbol)
     {
-        if (Function *definition = m_finder.findMatchingDefinition(symbol, m_snapshot))
+        if (Function *definition = m_finder.findMatchingDefinition(symbol, m_params.snapshot))
             return definition;
         return symbol;
     }
@@ -170,35 +166,26 @@ private:
         const QString text = m_overview.prettyName(LookupContext::fullyQualifiedName(symbol));
         const CPPEditorWidget::Link link = CPPEditorWidget::linkToSymbol(symbol);
 
-        BasicProposalItem *item = new VirtualFunctionProposalItem(link, m_openInNextSplit);
+        BasicProposalItem *item = new VirtualFunctionProposalItem(link, m_params.openInNextSplit);
         item->setText(text);
         item->setIcon(m_icons.iconForSymbol(symbol));
 
         return item;
     }
 
-    Class *m_startClass;
+    VirtualFunctionAssistProvider::Parameters m_params;
-    Function *m_function;
-    Snapshot m_snapshot;
-    bool m_openInNextSplit;
     Overview m_overview;
     Icons m_icons;
     CppTools::SymbolFinder m_finder;
 };
 
 VirtualFunctionAssistProvider::VirtualFunctionAssistProvider()
-    : m_function(0)
-    , m_openInNextSplit(false)
 {
 }
 
-bool VirtualFunctionAssistProvider::configure(Class *startClass, Function *function,
+bool VirtualFunctionAssistProvider::configure(const Parameters &parameters)
-                                              const Snapshot &snapshot, bool openInNextSplit)
 {
-    m_startClass = startClass;
+    m_params = parameters;
-    m_function = function;
-    m_snapshot = snapshot;
-    m_openInNextSplit = openInNextSplit;
     return true;
 }
 
@@ -214,7 +201,7 @@ bool VirtualFunctionAssistProvider::supportsEditor(const Core::Id &editorId) con
 
 IAssistProcessor *VirtualFunctionAssistProvider::createProcessor() const
 {
-    return new VirtualFunctionsAssistProcessor(this);
+    return new VirtualFunctionsAssistProcessor(m_params);
 }
 
 enum VirtualType { Virtual, PureVirtual };

src/plugins/cppeditor/cppvirtualfunctionassistprovider.h

@@ -35,6 +35,8 @@
 #include <cplusplus/CppDocument.h>
 #include <cplusplus/Symbols.h>
 
+#include <QTextCursor>
+
 namespace CppEditor {
 namespace Internal {
 
@@ -43,22 +45,24 @@ class VirtualFunctionAssistProvider : public TextEditor::IAssistProvider
 public:
     VirtualFunctionAssistProvider();
 
-    virtual bool configure(CPlusPlus::Class *startClass, CPlusPlus::Function *function,
+    struct Parameters {
-        const CPlusPlus::Snapshot &snapshot, bool openInNextSplit);
+        Parameters() : startClass(0), function(0), openInNextSplit(false) {}
-    CPlusPlus::Class *startClass() const { return m_startClass; }
+
-    CPlusPlus::Function *function() const { return m_function; }
+        CPlusPlus::Class *startClass;
-    CPlusPlus::Snapshot snapshot() const { return m_snapshot; }
+        CPlusPlus::Function *function;
-    bool openInNextSplit() const { return m_openInNextSplit; }
+        CPlusPlus::Snapshot snapshot;
+        bool openInNextSplit;
+    };
+
+    virtual bool configure(const Parameters &parameters);
+    Parameters params() const { return m_params; }
 
     bool isAsynchronous() const;
     bool supportsEditor(const Core::Id &editorId) const;
     TextEditor::IAssistProcessor *createProcessor() const;
 
 private:
-    CPlusPlus::Class *m_startClass;
+    Parameters m_params;
-    CPlusPlus::Function *m_function;
-    CPlusPlus::Snapshot m_snapshot;
-    bool m_openInNextSplit;
 };
 
 class FunctionHelper

src/plugins/cppeditor/followsymbol_switchmethoddecldef_test.cpp

@@ -100,10 +100,9 @@ public:
     // Invoke the processor already here to calculate the proposals. Return false in order to
     // indicate that configure failed, so the actual code assist invocation leading to a pop-up
     // will not happen.
-    bool configure(CPlusPlus::Class *startClass, CPlusPlus::Function *function,
+    bool configure(const VirtualFunctionAssistProvider::Parameters &params)
-                   const CPlusPlus::Snapshot &snapshot, bool openInNextSplit)
     {
-        VirtualFunctionAssistProvider::configure(startClass, function, snapshot, openInNextSplit);
+        VirtualFunctionAssistProvider::configure(params);
 
         IAssistProcessor *processor = createProcessor();
         IAssistInterface *assistInterface