ToolChain: Create toolchains for different languages

Enable creation of toolchains for different languages and wire
up the logic in the ToolChain Options Page.

Change-Id: I9fbd95607d30cc1aa10f73d6532338f07f3e2b4e
Reviewed-by: Tim Jenssen <tim.jenssen@theqtcompany.com>

src/plugins/projectexplorer/customtoolchain.cpp

@@ -88,10 +88,14 @@ static const char messageCapKeyC[] = "ProjectExplorer.CustomToolChain.MessageCap
 CustomToolChain::CustomToolChain(Detection d) :
     ToolChain(Constants::CUSTOM_TOOLCHAIN_TYPEID, d),
     m_outputParser(Gcc)
+{ }
+
+CustomToolChain::CustomToolChain(Language l, Detection d) : CustomToolChain(d)
 {
-    setLanguage(Language::Cxx);
+    setLanguage(l);
 }
 
+
 QString CustomToolChain::typeDisplayName() const
 {
     return Internal::CustomToolChainFactory::tr("Custom");
@@ -434,7 +438,7 @@ CustomToolChainFactory::CustomToolChainFactory()
 
 QSet<ToolChain::Language> CustomToolChainFactory::supportedLanguages() const
 {
-    return { ToolChain::Language::Cxx };
+    return ToolChain::allLanguages();
 }
 
 bool CustomToolChainFactory::canCreate()
@@ -442,9 +446,9 @@ bool CustomToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *CustomToolChainFactory::create()
+ToolChain *CustomToolChainFactory::create(ToolChain::Language l)
 {
-    return new CustomToolChain(ToolChain::ManualDetection);
+    return new CustomToolChain(l, ToolChain::ManualDetection);
 }
 
 // Used by the ToolChainManager to restore user-generated tool chains

src/plugins/projectexplorer/customtoolchain.h

@@ -122,6 +122,7 @@ protected:
 
 private:
     explicit CustomToolChain(Detection d);
+    explicit CustomToolChain(Language l, Detection d);
 
     Utils::FileName m_compilerCommand;
     Utils::FileName m_makeCommand;
@@ -150,7 +151,7 @@ public:
     QSet<ToolChain::Language> supportedLanguages() const override;
 
     bool canCreate() override;
-    ToolChain *create() override;
+    ToolChain *create(ToolChain::Language l) override;
 
     // Used by the ToolChainManager to restore user-generated tool chains
     bool canRestore(const QVariantMap &data) override;

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -771,7 +771,7 @@ GccToolChainFactory::GccToolChainFactory()
 
 QSet<ToolChain::Language> GccToolChainFactory::supportedLanguages() const
 {
-    return { ToolChain::Language::Cxx };
+    return { ToolChain::Language::Cxx, ToolChain::Language::C };
 }
 
 bool GccToolChainFactory::canCreate()
@@ -779,10 +779,10 @@ bool GccToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *GccToolChainFactory::create()
+ToolChain *GccToolChainFactory::create(ToolChain::Language l)
 {
     ToolChain *tc = createToolChain(false);
-    tc->setLanguage({ ToolChain::Language::Cxx });
+    tc->setLanguage(l);
     return tc;
 }
 
@@ -1141,7 +1141,7 @@ ClangToolChainFactory::ClangToolChainFactory()
 
 QSet<ToolChain::Language> ClangToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx };
+    return { ProjectExplorer::ToolChain::Language::Cxx, ProjectExplorer::ToolChain::Language::C };
 }
 
 QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)

src/plugins/projectexplorer/gcctoolchainfactories.h

@@ -54,7 +54,7 @@ public:
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
     bool canCreate() override;
-    ToolChain *create() override;
+    ToolChain *create(ToolChain::Language l) override;
 
     bool canRestore(const QVariantMap &data) override;
     ToolChain *restore(const QVariantMap &data) override;

src/plugins/projectexplorer/toolchain.cpp

@@ -291,8 +291,9 @@ bool ToolChainFactory::canCreate()
     return false;
 }
 
-ToolChain *ToolChainFactory::create()
+ToolChain *ToolChainFactory::create(ToolChain::Language l)
 {
+    Q_UNUSED(l);
     return nullptr;
 }
 

src/plugins/projectexplorer/toolchain.h

@@ -166,7 +166,7 @@ public:
     virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown);
 
     virtual bool canCreate();
-    virtual ToolChain *create();
+    virtual ToolChain *create(ToolChain::Language l);
 
     virtual bool canRestore(const QVariantMap &data);
     virtual ToolChain *restore(const QVariantMap &data);

src/plugins/projectexplorer/toolchainoptionspage.cpp

@@ -152,27 +152,20 @@ public:
                 continue;
 
             if (languages.count() == 1) {
-                QAction *action = new QAction(addMenu);
+                addMenu->addAction(createAction(factory->displayName(), factory, languages.at(0)));
-                action->setText(factory->displayName());
-                connect(action, &QAction::triggered, [this, factory] { createToolChain(factory); });
-                addMenu->addAction(action);
             } else {
                 Utils::sort(languages, [](ToolChain::Language l1, ToolChain::Language l2) {
                                 return ToolChain::languageDisplayName(l1) < ToolChain::languageDisplayName(l2);
                             });
                 auto subMenu = addMenu->addMenu(factory->displayName());
-                foreach (ToolChain::Language l, languages) {
+                foreach (ToolChain::Language l, languages)
-                    auto action = new QAction(subMenu);
+                    subMenu->addAction(createAction(ToolChain::languageDisplayName(l), factory, l));
-                    action->setText(ToolChain::languageDisplayName(l));
-                    connect(action, &QAction::triggered, [this, factory] { createToolChain(factory); });
-                    subMenu->addAction(action);
-                }
             }
         }
         m_addButton->setMenu(addMenu);
 
         m_cloneButton = new QPushButton(ToolChainOptionsPage::tr("Clone"), this);
-        connect(m_cloneButton, &QAbstractButton::clicked, [this] { createToolChain(nullptr); });
+        connect(m_cloneButton, &QAbstractButton::clicked, [this] { cloneToolChain(); });
 
         m_delButton = new QPushButton(ToolChainOptionsPage::tr("Remove"), this);
 
@@ -216,7 +209,8 @@ public:
 
     void toolChainSelectionChanged();
     void updateState();
-    void createToolChain(ToolChainFactory *factory);
+    void createToolChain(ToolChainFactory *factory, ToolChain::Language l);
+    void cloneToolChain();
     ToolChainTreeItem *currentTreeItem();
 
     void markForRemoval(ToolChainTreeItem *item);
@@ -225,6 +219,12 @@ public:
     void removeToolChain(ProjectExplorer::ToolChain *);
 
     StaticTreeItem *parentForToolChain(ToolChain *tc);
+    QAction *createAction(const QString &name, ToolChainFactory *factory, ToolChain::Language l)
+    {
+        auto action = new QAction(name, nullptr);
+        connect(action, &QAction::triggered, [this, factory, l] { createToolChain(factory, l); });
+        return action;
+    }
 
     void apply();
 
@@ -374,21 +374,28 @@ void ToolChainOptionsWidget::apply()
     }
 }
 
-void ToolChainOptionsWidget::createToolChain(ToolChainFactory *factory)
+void ToolChainOptionsWidget::createToolChain(ToolChainFactory *factory, ToolChain::Language l)
 {
-    ToolChain *tc = nullptr;
+    QTC_ASSERT(factory, return);
+    QTC_ASSERT(factory->canCreate(), return);
+    QTC_ASSERT(l != ToolChain::Language::None, return);
 
-    if (factory) {
+    ToolChain *tc = factory->create(l);
-        // Clone.
+    if (!tc)
-        QTC_CHECK(factory->canCreate());
+        return;
-        tc = factory->create();
+
-    } else {
+    auto item = insertToolChain(tc, true);
-        // Copy.
+    m_toAddList.append(item);
-        ToolChainTreeItem *current = currentTreeItem();
+
-        if (!current)
+    m_toolChainView->setCurrentIndex(m_model.indexForItem(item));
-            return;
+}
-        tc = current->toolChain->clone();
+
-    }
+void ToolChainOptionsWidget::cloneToolChain()
+{
+    ToolChainTreeItem *current = currentTreeItem();
+    if (!current)
+        return;
+    ToolChain *tc = current->toolChain->clone();
 
     if (!tc)
         return;

src/plugins/qnx/qnxtoolchain.cpp

@@ -185,9 +185,9 @@ bool QnxToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *QnxToolChainFactory::create()
+ToolChain *QnxToolChainFactory::create(ToolChain::Language l)
 {
-    return new QnxToolChain(ToolChain::ManualDetection);
+    return new QnxToolChain(l, ToolChain::ManualDetection);
 }
 
 //---------------------------------------------------------------------------------

src/plugins/qnx/qnxtoolchain.h

@@ -75,7 +75,7 @@ public:
     ProjectExplorer::ToolChain *restore(const QVariantMap &data) override;
 
     bool canCreate() override;
-    ProjectExplorer::ToolChain *create() override;
+    ProjectExplorer::ToolChain *create(ProjectExplorer::ToolChain::Language l) override;
 };
 
 //----------------------------------------------------------------------------