Merge remote-tracking branch 'origin/3.5'

Change-Id: I8eeb30833ca9c1a021b367f8e47f9b89da8afe01

plugins/clangstaticanalyzer/clangstaticanalyzerconfigwidget.cpp

@@ -40,11 +40,31 @@ ClangStaticAnalyzerConfigWidget::ClangStaticAnalyzerConfigWidget(
     chooser->setHistoryCompleter(QLatin1String("ClangStaticAnalyzer.ClangCommand.History"));
     chooser->setPromptDialogTitle(tr("Clang Command"));
     const auto validator = [chooser](Utils::FancyLineEdit *edit, QString *errorMessage) {
-        return chooser->defaultValidationFunction()(edit, errorMessage)
-                && isClangExecutableUsable(chooser->fileName().toString(), errorMessage);
+        const QString currentFilePath = chooser->fileName().toString();
+        Utils::PathChooser pc;
+        Utils::PathChooser *helperPathChooser;
+        if (currentFilePath.isEmpty()) {
+            pc.setExpectedKind(chooser->expectedKind());
+            pc.setPath(edit->placeholderText());
+            helperPathChooser = &pc;
+        } else {
+            helperPathChooser = chooser;
+        }
+        return chooser->defaultValidationFunction()(helperPathChooser->lineEdit(), errorMessage)
+                && isClangExecutableUsable(helperPathChooser->fileName().toString(), errorMessage);
     };
     chooser->setValidationFunction(validator);
-    chooser->setPath(settings->clangExecutable());
+    bool clangExeIsSet;
+    const QString clangExe = settings->clangExecutable(&clangExeIsSet);
+    chooser->lineEdit()->setPlaceholderText(settings->defaultClangExecutable());
+    if (clangExeIsSet) {
+        chooser->setPath(clangExe);
+    } else {
+        // Setting an empty string does not trigger the validator, as that is the initial value
+        // in the line edit.
+        chooser->setPath(QLatin1String(" "));
+        chooser->lineEdit()->clear();
+    }
     connect(m_ui->clangExecutableChooser, &Utils::PathChooser::changed,
             [settings](const QString &path) { settings->setClangExecutable(path); });
 

plugins/clangstaticanalyzer/clangstaticanalyzerconstants.h

@@ -22,7 +22,6 @@
 namespace ClangStaticAnalyzer {
 namespace Constants {
 
-const char CLANG_EXECUTABLE_BASE_NAME[] = "clang";
 const char SETTINGS_ID[] = "ClangStaticAnalyzer";
 const char CLANGSTATICANALYZER_RUN_MODE[] = "ClangStaticAnalyzer.RunMode";
 

plugins/clangstaticanalyzer/clangstaticanalyzerlicensecheck.h

@@ -31,8 +31,12 @@ inline bool enterpriseFeaturesAvailable()
             = ExtensionSystem::PluginManager::getObject<LicenseChecker::LicenseCheckerPlugin>();
 
     if (licenseChecker && licenseChecker->hasValidLicense()) {
-        if (licenseChecker->enterpriseFeatures())
+        if (licenseChecker->enterpriseFeatures()) {
             return true;
+        } else {
+            qWarning() << "License does not cover enterprise features, "
+                          "disabling Clang Static Analyzer";
+        }
     } else {
         qWarning() << "Invalid license, disabling Clang Static Analyzer";
     }

plugins/clangstaticanalyzer/clangstaticanalyzersettings.cpp

@@ -46,14 +46,34 @@ ClangStaticAnalyzerSettings *ClangStaticAnalyzerSettings::instance()
     return &instance;
 }
 
-QString ClangStaticAnalyzerSettings::clangExecutable() const
+static QString clangExecutableFileName()
 {
+    return QLatin1String(Utils::HostOsInfo::isWindowsHost() ? "clang-cl.exe" : "clang");
+}
+
+QString ClangStaticAnalyzerSettings::defaultClangExecutable() const
+{
+    const QString shippedBinary = Core::ICore::libexecPath() + QLatin1Char('/')
+            + clangExecutableFileName();
+    if (QFileInfo(shippedBinary).isExecutable())
+        return shippedBinary;
+    return clangExecutableFileName();
+}
+
+QString ClangStaticAnalyzerSettings::clangExecutable(bool *isSet) const
+{
+    if (m_clangExecutable.isEmpty()) {
+        if (isSet)
+            *isSet = false;
+        return defaultClangExecutable();
+    }
+    if (isSet)
+        *isSet = true;
     return m_clangExecutable;
 }
 
 void ClangStaticAnalyzerSettings::setClangExecutable(const QString &exectuable)
 {
-    QTC_ASSERT(!exectuable.isEmpty(), return);
     m_clangExecutable = exectuable;
 }
 
@@ -73,10 +93,7 @@ void ClangStaticAnalyzerSettings::readSettings()
     QSettings *settings = Core::ICore::settings();
     settings->beginGroup(QLatin1String(Constants::SETTINGS_ID));
 
-    const QString defaultClangExecutable = Utils::HostOsInfo::withExecutableSuffix(
-                QLatin1String(Constants::CLANG_EXECUTABLE_BASE_NAME));
-    setClangExecutable(settings->value(QLatin1String(clangExecutableKey),
-                                       defaultClangExecutable).toString());
+    setClangExecutable(settings->value(QLatin1String(clangExecutableKey)).toString());
 
     const int defaultSimultaneousProcesses = qMax(0, QThread::idealThreadCount() / 2);
     setSimultaneousProcesses(settings->value(QLatin1String(simultaneousProcessesKey),
@@ -89,7 +106,7 @@ void ClangStaticAnalyzerSettings::writeSettings() const
 {
     QSettings *settings = Core::ICore::settings();
     settings->beginGroup(QLatin1String(Constants::SETTINGS_ID));
-    settings->setValue(QLatin1String(clangExecutableKey), clangExecutable());
+    settings->setValue(QLatin1String(clangExecutableKey), m_clangExecutable);
     settings->setValue(QLatin1String(simultaneousProcessesKey), simultaneousProcesses());
     settings->endGroup();
 }

plugins/clangstaticanalyzer/clangstaticanalyzersettings.h

@@ -31,7 +31,8 @@ public:
 
     void writeSettings() const;
 
-    QString clangExecutable() const;
+    QString defaultClangExecutable() const;
+    QString clangExecutable(bool *isSet = nullptr) const;
     void setClangExecutable(const QString &exectuable);
 
     int simultaneousProcesses() const;