QmlJsEditor: Partially aspectify settings

Only the non-gui part for now.

Change-Id: I97e59f6cb251bfb1be4dd88cc2c2f9c2e71ce219
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

src/libs/utils/aspects.cpp

@@ -2942,12 +2942,12 @@ void FilePathListAspect::removeValues(const FilePaths &paths)
 }
 
 /*!
-    \class Utils::IntegerListAspect
+    \class Utils::IntegersAspect
     \internal
     \inmodule QtCreator
 
-    \brief A string list aspect represents a property of some object
+    \brief An integers aspect represents a property of some object
-    that is a list of strings.
+    that is a list of integers.
 */
 
 IntegersAspect::IntegersAspect(AspectContainer *container)

src/plugins/qmljseditor/qmljseditorsettings.cpp

@@ -182,159 +182,56 @@ static QList<int> defaultDisabledMessagesNonQuickUi()
     return disabledForNonQuickUi;
 }
 
-static QStringList intListToStringList(const QList<int> &list)
+static QVariant toSettingsTransformation(const QVariant &v)
 {
-    return Utils::transform(list, [](int v) { return QString::number(v); });
+    QList<int> list = v.value<QList<int>>();
+    QStringList result = Utils::transform<QStringList>(list, [](int i) { return QString::number(i); });
+    return QVariant::fromValue(result);
 }
 
-static QList<int> intListFromStringList(const QStringList &list)
+static QVariant fromSettingsTransformation(const QVariant &v)
 {
-    return Utils::transform<QList<int> >(list, [](const QString &v) { return v.toInt(); });
+    QStringList list = v.value<QStringList>();
-}
+    QList<int> result =  Utils::transform<QList<int>>(list, [](const QString &s) { return s.toInt(); });
-
+    return QVariant::fromValue(result);
-static QStringList defaultDisabledMessagesAsString()
-{
-    static const QStringList result = intListToStringList(defaultDisabledMessages());
-    return result;
-}
-
-static QStringList defaultDisabledNonQuickUiAsString()
-{
-    static const QStringList result = intListToStringList(defaultDisabledMessagesNonQuickUi());
-    return result;
 }
 
 QmlJsEditingSettings::QmlJsEditingSettings()
 {
-    QtcSettings *settings = Core::ICore::settings();
+    const Key group = QmlJSEditor::Constants::SETTINGS_CATEGORY_QML;
 
-    settings->beginGroup(QmlJSEditor::Constants::SETTINGS_CATEGORY_QML);
+    useQmlls.setSettingsKey(group, USE_QMLLS);
-    m_enableContextPane = settings->value(QML_CONTEXTPANE_KEY, QVariant(false)).toBool();
+    useQmlls.setDefaultValue(true);
-    m_pinContextPane = settings->value(QML_CONTEXTPANEPIN_KEY, QVariant(false)).toBool();
-    m_autoFormatOnSave = settings->value(AUTO_FORMAT_ON_SAVE, QVariant(false)).toBool();
-    m_autoFormatOnlyCurrentProject
-        = settings->value(AUTO_FORMAT_ONLY_CURRENT_PROJECT, QVariant(false)).toBool();
-    m_foldAuxData = settings->value(FOLD_AUX_DATA, QVariant(true)).toBool();
-    m_uiQmlOpenMode = settings->value(UIQML_OPEN_MODE, "").toString();
-    m_useQmlls = settings->value(USE_QMLLS, QVariant(true)).toBool();
-    m_useLatestQmlls = settings->value(USE_LATEST_QMLLS, QVariant(false)).toBool();
-    m_ignoreMinimumQmllsVersion
-        = settings->value(IGNORE_MINIMUM_QMLLS_VERSION, QVariant(false)).toBool();
-    m_disableBuiltinCodemodel = settings->value(DISABLE_BUILTIN_CODEMODEL, QVariant(false)).toBool();
-    m_generateQmllsIniFiles
-        = settings->value(GENERATE_QMLLS_INI_FILES, QVariant(false)).toBool();
-    m_formatCommand = settings->value(FORMAT_COMMAND, {}).toString();
-    m_formatCommandOptions = settings->value(FORMAT_COMMAND_OPTIONS, {}).toString();
-    m_useCustomFormatCommand = settings->value(CUSTOM_COMMAND, QVariant(false)).toBool();
-    m_useCustomAnalyzer = settings->value(CUSTOM_ANALYZER, QVariant(false)).toBool();
 
-    m_disabledMessages = Utils::toSet(
+    enableContextPane.setSettingsKey(group, QML_CONTEXTPANE_KEY);
-        intListFromStringList(settings->value(DISABLED_MESSAGES,
+    pinContextPane.setSettingsKey(group, QML_CONTEXTPANEPIN_KEY);
-                              defaultDisabledMessagesAsString()).toStringList()));
+    autoFormatOnSave.setSettingsKey(group, AUTO_FORMAT_ON_SAVE);
+    autoFormatOnlyCurrentProject.setSettingsKey(group, AUTO_FORMAT_ONLY_CURRENT_PROJECT);
 
-    m_disabledMessagesForNonQuickUi = Utils::toSet(
+    foldAuxData.setSettingsKey(group, FOLD_AUX_DATA);
-        intListFromStringList(settings->value(DISABLED_MESSAGES_NONQUICKUI,
+    foldAuxData.setDefaultValue(true);
-                              defaultDisabledNonQuickUiAsString()).toStringList()));
 
-    settings->endGroup();
+    uiQmlOpenMode.setSettingsKey(group, UIQML_OPEN_MODE);
-}
+    useLatestQmlls.setSettingsKey(group, USE_LATEST_QMLLS);
+    disableBuiltinCodemodel.setSettingsKey(group, DISABLE_BUILTIN_CODEMODEL);
+    generateQmllsIniFiles.setSettingsKey(group, GENERATE_QMLLS_INI_FILES);
+    ignoreMinimumQmllsVersion.setSettingsKey(group, IGNORE_MINIMUM_QMLLS_VERSION);
+    formatCommand.setSettingsKey(group, FORMAT_COMMAND);
+    formatCommandOptions.setSettingsKey(group, FORMAT_COMMAND_OPTIONS);
+    useCustomFormatCommand.setSettingsKey(group, CUSTOM_COMMAND);
+    useCustomAnalyzer.setSettingsKey(group, CUSTOM_ANALYZER);
 
-void QmlJsEditingSettings::toSettings(QtcSettings *settings) const
+    disabledMessages.setSettingsKey(group, DISABLED_MESSAGES);
-{
+    disabledMessages.setDefaultValue(defaultDisabledMessages());
-    settings->beginGroup(QmlJSEditor::Constants::SETTINGS_CATEGORY_QML);
+    disabledMessages.setFromSettingsTransformation(&fromSettingsTransformation);
-    settings->setValue(QML_CONTEXTPANE_KEY, m_enableContextPane);
+    disabledMessages.setToSettingsTransformation(&toSettingsTransformation);
-    settings->setValue(QML_CONTEXTPANEPIN_KEY, m_pinContextPane);
-    settings->setValue(AUTO_FORMAT_ON_SAVE, m_autoFormatOnSave);
-    settings->setValue(AUTO_FORMAT_ONLY_CURRENT_PROJECT, m_autoFormatOnlyCurrentProject);
-    settings->setValue(FOLD_AUX_DATA, m_foldAuxData);
-    settings->setValue(UIQML_OPEN_MODE, m_uiQmlOpenMode);
-    settings->setValue(USE_QMLLS, m_useQmlls);
-    settings->setValue(USE_LATEST_QMLLS, m_useLatestQmlls);
-    settings->setValue(IGNORE_MINIMUM_QMLLS_VERSION, m_ignoreMinimumQmllsVersion);
-    settings->setValue(DISABLE_BUILTIN_CODEMODEL, m_disableBuiltinCodemodel);
-    settings->setValue(GENERATE_QMLLS_INI_FILES, m_generateQmllsIniFiles);
-    settings->setValueWithDefault(FORMAT_COMMAND, m_formatCommand, {});
-    settings->setValueWithDefault(FORMAT_COMMAND_OPTIONS, m_formatCommandOptions, {});
-    settings->setValueWithDefault(CUSTOM_COMMAND, m_useCustomFormatCommand, false);
-    settings->setValueWithDefault(CUSTOM_ANALYZER, m_useCustomAnalyzer, false);
-    settings->setValueWithDefault(DISABLED_MESSAGES,
-                                  intListToStringList(Utils::sorted(Utils::toList(m_disabledMessages))),
-                                  defaultDisabledMessagesAsString());
-    settings->setValueWithDefault(DISABLED_MESSAGES_NONQUICKUI,
-                                  intListToStringList(Utils::sorted(Utils::toList(m_disabledMessagesForNonQuickUi))),
-                                  defaultDisabledNonQuickUiAsString());
-    settings->endGroup();
-    QmllsSettingsManager::instance()->checkForChanges();
-}
 
-bool QmlJsEditingSettings::equals(const QmlJsEditingSettings &other) const
+    disabledMessagesForNonQuickUi.setSettingsKey(group, DISABLED_MESSAGES_NONQUICKUI);
-{
+    disabledMessagesForNonQuickUi.setDefaultValue(defaultDisabledMessagesNonQuickUi());
-    return m_enableContextPane == other.m_enableContextPane
+    disabledMessagesForNonQuickUi.setFromSettingsTransformation(&fromSettingsTransformation);
-           && m_pinContextPane == other.m_pinContextPane
+    disabledMessagesForNonQuickUi.setToSettingsTransformation(&toSettingsTransformation);
-           && m_autoFormatOnSave == other.m_autoFormatOnSave
-           && m_autoFormatOnlyCurrentProject == other.m_autoFormatOnlyCurrentProject
-           && m_foldAuxData == other.m_foldAuxData
-           && m_useQmlls == other.m_useQmlls
-           && m_useLatestQmlls == other.m_useLatestQmlls
-           && m_disableBuiltinCodemodel == other.m_disableBuiltinCodemodel
-           && m_generateQmllsIniFiles == other.m_generateQmllsIniFiles
-           && m_uiQmlOpenMode == other.m_uiQmlOpenMode
-           && m_formatCommand == other.m_formatCommand
-           && m_formatCommandOptions == other.m_formatCommandOptions
-           && m_useCustomFormatCommand == other.m_useCustomFormatCommand
-           && m_useCustomAnalyzer == other.m_useCustomAnalyzer
-           && m_disabledMessages == other.m_disabledMessages
-           && m_disabledMessagesForNonQuickUi == other.m_disabledMessagesForNonQuickUi;
-}
 
-bool QmlJsEditingSettings::enableContextPane() const
+    readSettings();
-{
-    return m_enableContextPane;
-}
-
-void QmlJsEditingSettings::setEnableContextPane(const bool enableContextPane)
-{
-    m_enableContextPane = enableContextPane;
-}
-
-bool QmlJsEditingSettings::pinContextPane() const
-{
-    return m_pinContextPane;
-}
-
-void QmlJsEditingSettings::setPinContextPane(const bool pinContextPane)
-{
-    m_pinContextPane = pinContextPane;
-}
-
-bool QmlJsEditingSettings::autoFormatOnSave() const
-{
-    return m_autoFormatOnSave;
-}
-
-void QmlJsEditingSettings::setAutoFormatOnSave(const bool autoFormatOnSave)
-{
-    m_autoFormatOnSave = autoFormatOnSave;
-}
-
-bool QmlJsEditingSettings::autoFormatOnlyCurrentProject() const
-{
-    return m_autoFormatOnlyCurrentProject;
-}
-
-void QmlJsEditingSettings::setAutoFormatOnlyCurrentProject(const bool autoFormatOnlyCurrentProject)
-{
-    m_autoFormatOnlyCurrentProject = autoFormatOnlyCurrentProject;
-}
-
-bool QmlJsEditingSettings::foldAuxData() const
-{
-    return m_foldAuxData;
-}
-
-void QmlJsEditingSettings::setFoldAuxData(const bool foldAuxData)
-{
-    m_foldAuxData = foldAuxData;
 }
 
 QString QmlJsEditingSettings::defaultFormatCommand() const
@@ -342,126 +239,6 @@ QString QmlJsEditingSettings::defaultFormatCommand() const
     return DEFAULT_CUSTOM_FORMAT_COMMAND;
 }
 
-QString QmlJsEditingSettings::formatCommand() const
-{
-    return m_formatCommand;
-}
-
-void QmlJsEditingSettings::setFormatCommand(const QString &formatCommand)
-{
-    m_formatCommand = formatCommand;
-}
-
-QString QmlJsEditingSettings::formatCommandOptions() const
-{
-    return m_formatCommandOptions;
-}
-
-void QmlJsEditingSettings::setFormatCommandOptions(const QString &formatCommandOptions)
-{
-    m_formatCommandOptions = formatCommandOptions;
-}
-
-bool QmlJsEditingSettings::useCustomFormatCommand() const
-{
-    return m_useCustomFormatCommand;
-}
-
-void QmlJsEditingSettings::setUseCustomFormatCommand(bool customCommand)
-{
-    m_useCustomFormatCommand = customCommand;
-}
-
-const QString QmlJsEditingSettings::uiQmlOpenMode() const
-{
-    return m_uiQmlOpenMode;
-}
-
-void QmlJsEditingSettings::setUiQmlOpenMode(const QString &mode)
-{
-    m_uiQmlOpenMode = mode;
-}
-
-bool QmlJsEditingSettings::useCustomAnalyzer() const
-{
-    return m_useCustomAnalyzer;
-}
-
-void QmlJsEditingSettings::setUseCustomAnalyzer(bool customAnalyzer)
-{
-    m_useCustomAnalyzer = customAnalyzer;
-}
-
-QSet<int> QmlJsEditingSettings::disabledMessages() const
-{
-    return m_disabledMessages;
-}
-
-void QmlJsEditingSettings::setDisabledMessages(const QSet<int> &disabled)
-{
-    m_disabledMessages = disabled;
-}
-
-QSet<int> QmlJsEditingSettings::disabledMessagesForNonQuickUi() const
-{
-    return m_disabledMessagesForNonQuickUi;
-}
-
-void QmlJsEditingSettings::setDisabledMessagesForNonQuickUi(const QSet<int> &disabled)
-{
-    m_disabledMessagesForNonQuickUi = disabled;
-}
-
-bool QmlJsEditingSettings::generateQmllsIniFiles() const
-{
-    return m_generateQmllsIniFiles;
-}
-
-void QmlJsEditingSettings::setGenerateQmllsIniFiles(bool newGenerateQmllsIniFiles)
-{
-    m_generateQmllsIniFiles = newGenerateQmllsIniFiles;
-}
-
-bool QmlJsEditingSettings::disableBuiltinCodemodel() const
-{
-    return m_disableBuiltinCodemodel;
-}
-
-void QmlJsEditingSettings::setDisableBuiltinCodemodel(bool newDisableBuiltinCodemodel)
-{
-    m_disableBuiltinCodemodel = newDisableBuiltinCodemodel;
-}
-
-bool QmlJsEditingSettings::useLatestQmlls() const
-{
-    return m_useLatestQmlls;
-}
-
-void QmlJsEditingSettings::setUseLatestQmlls(bool newUseLatestQmlls)
-{
-    m_useLatestQmlls = newUseLatestQmlls;
-}
-
-bool QmlJsEditingSettings::ignoreMinimumQmllsVersion() const
-{
-    return m_ignoreMinimumQmllsVersion;
-}
-
-void QmlJsEditingSettings::setIgnoreMinimumQmllsVersion(bool newIgnoreMinimumQmllsVersion)
-{
-    m_ignoreMinimumQmllsVersion = newIgnoreMinimumQmllsVersion;
-}
-
-bool QmlJsEditingSettings::useQmlls() const
-{
-    return m_useQmlls;
-}
-
-void QmlJsEditingSettings::setUseQmlls(bool newUseQmlls)
-{
-    m_useQmlls = newUseQmlls;
-}
-
 class AnalyzerMessageItem final : public Utils::TreeItem
 {
 public:
@@ -667,37 +444,39 @@ public:
     void apply() final
     {
         QmlJsEditingSettings &s = settings();
-        s.setEnableContextPane(enableContextPane->isChecked());
+        s.enableContextPane.setValue(enableContextPane->isChecked());
-        s.setPinContextPane(pinContextPane->isChecked());
+        s.pinContextPane.setValue(pinContextPane->isChecked());
-        s.setAutoFormatOnSave(autoFormatOnSave->isChecked());
+        s.autoFormatOnSave.setValue(autoFormatOnSave->isChecked());
-        s.setAutoFormatOnlyCurrentProject(autoFormatOnlyCurrentProject->isChecked());
+        s.autoFormatOnlyCurrentProject.setValue(autoFormatOnlyCurrentProject->isChecked());
-        s.setUseCustomFormatCommand(useCustomFormatCommand->isChecked());
+        s.useCustomFormatCommand.setValue(useCustomFormatCommand->isChecked());
-        s.setFormatCommand(formatCommand->text());
+        s.formatCommand.setValue(formatCommand->text());
-        s.setFormatCommandOptions(formatCommandOptions->text());
+        s.formatCommandOptions.setValue(formatCommandOptions->text());
-        s.setFoldAuxData(foldAuxData->isChecked());
+        s.foldAuxData.setValue(foldAuxData->isChecked());
-        s.setUiQmlOpenMode(uiQmlOpenComboBox->currentData().toString());
+        s.uiQmlOpenMode.setValue(uiQmlOpenComboBox->currentData().toString());
-        s.setUseQmlls(useQmlls->isChecked());
+        s.useQmlls.setValue(useQmlls->isChecked());
-        s.setDisableBuiltinCodemodel(disableBuiltInCodemodel->isChecked());
+        s.disableBuiltinCodemodel.setValue(disableBuiltInCodemodel->isChecked());
-        s.setUseLatestQmlls(useLatestQmlls->isChecked());
+        s.ignoreMinimumQmllsVersion.setValue(ignoreMinimumQmllsVersion->isChecked());
-        s.setIgnoreMinimumQmllsVersion(ignoreMinimumQmllsVersion->isChecked());
+        s.useLatestQmlls.setValue(useLatestQmlls->isChecked());
-        s.setGenerateQmllsIniFiles(generateQmllsIniFiles->isChecked());
+        s.generateQmllsIniFiles.setValue(generateQmllsIniFiles->isChecked());
-        s.setUseCustomAnalyzer(useCustomAnalyzer->isChecked());
+        s.useCustomAnalyzer.setValue(useCustomAnalyzer->isChecked());
-        QSet<int> disabled;
+        QList<int> disabled;
-        QSet<int> disabledForNonQuickUi;
+        QList<int> disabledForNonQuickUi;
+
         analyzerMessageModel->forAllItems(
             [&disabled, &disabledForNonQuickUi](AnalyzerMessageItem *item){
             if (item->data(0, Qt::CheckStateRole) == Qt::Unchecked)
-                disabled.insert(item->messageNumber());
+                disabled.append(item->messageNumber());
             if (item->data(1, Qt::CheckStateRole) == Qt::Checked)
-                disabledForNonQuickUi.insert(item->messageNumber());
+                disabledForNonQuickUi.append(item->messageNumber());
         });
-        s.setDisabledMessages(disabled);
+        s.disabledMessages.setValue(disabled);
-        s.setDisabledMessagesForNonQuickUi(disabledForNonQuickUi);
+        s.disabledMessagesForNonQuickUi.setValue(disabledForNonQuickUi);
-        s.toSettings(Core::ICore::settings());
+        s.writeSettings();
+        QmllsSettingsManager::instance()->checkForChanges();
     }
 
 private:
-    void populateAnalyzerMessages(const QSet<int> &disabled, const QSet<int> &disabledForNonQuickUi)
+    void populateAnalyzerMessages(const QList<int> &disabled, const QList<int> &disabledForNonQuickUi)
     {
         using namespace QmlJS::StaticAnalysis;
         auto knownMessages = Utils::sorted(Message::allMessageTypes());
@@ -721,8 +500,8 @@ private:
         menu.addAction(reset);
         connect(reset, &QAction::triggered, this, [this](){
             analyzerMessageModel->clear();
-            populateAnalyzerMessages(Utils::toSet(defaultDisabledMessages()),
+            populateAnalyzerMessages(defaultDisabledMessages(),
-                                     Utils::toSet(defaultDisabledMessagesNonQuickUi()));
+                                     defaultDisabledMessagesNonQuickUi());
 
         });
         menu.exec(analyzerMessagesView->mapToGlobal(position));

src/plugins/qmljseditor/qmljseditorsettings.h

@@ -13,92 +13,32 @@
 
 namespace QmlJSEditor::Internal {
 
-class QmlJsEditingSettings
+class QmlJsEditingSettings final : public Utils::AspectContainer
 {
 public:
     static const inline QVersionNumber mininumQmllsVersion = QVersionNumber(6, 8);
 
     QmlJsEditingSettings();
 
-    void toSettings(Utils::QtcSettings *) const;
-
-    bool equals(const QmlJsEditingSettings &other) const;
-
-    bool enableContextPane() const;
-    void setEnableContextPane(const bool enableContextPane);
-
-    bool pinContextPane() const;
-    void setPinContextPane(const bool pinContextPane);
-
-    bool autoFormatOnSave() const;
-    void setAutoFormatOnSave(const bool autoFormatOnSave);
-
-    bool autoFormatOnlyCurrentProject() const;
-    void setAutoFormatOnlyCurrentProject(const bool autoFormatOnlyCurrentProject);
-
-    bool foldAuxData() const;
-    void setFoldAuxData(const bool foldAuxData);
-
     QString defaultFormatCommand() const;
-    QString formatCommand() const;
-    void setFormatCommand(const QString &formatCommand);
 
-    QString formatCommandOptions() const;
+    Utils::BoolAspect enableContextPane{this};
-    void setFormatCommandOptions(const QString &formatCommandOptions);
+    Utils::BoolAspect pinContextPane{this};
-
+    Utils::BoolAspect autoFormatOnSave{this};
-    bool useCustomFormatCommand() const;
+    Utils::BoolAspect autoFormatOnlyCurrentProject{this};
-    void setUseCustomFormatCommand(bool customCommand);
+    Utils::BoolAspect foldAuxData{this};
-
+    Utils::BoolAspect useCustomFormatCommand{this};
-    const QString uiQmlOpenMode() const;
+    Utils::BoolAspect useCustomAnalyzer{this};
-    void setUiQmlOpenMode(const QString &mode);
+    Utils::BoolAspect useQmlls{this};
-
+    Utils::BoolAspect useLatestQmlls{this};
-    bool useCustomAnalyzer() const;
+    Utils::BoolAspect ignoreMinimumQmllsVersion{this};
-    void setUseCustomAnalyzer(bool customAnalyzer);
+    Utils::BoolAspect disableBuiltinCodemodel{this};
-
+    Utils::BoolAspect generateQmllsIniFiles{this};
-    QSet<int> disabledMessages() const;
+    Utils::StringAspect uiQmlOpenMode{this};
-    void setDisabledMessages(const QSet<int> &disabled);
+    Utils::StringAspect formatCommand{this};
-
+    Utils::StringAspect formatCommandOptions{this};
-    QSet<int> disabledMessagesForNonQuickUi() const;
+    Utils::IntegersAspect disabledMessages{this};
-    void setDisabledMessagesForNonQuickUi(const QSet<int> &disabled);
+    Utils::IntegersAspect disabledMessagesForNonQuickUi{this};
-
-    bool useQmlls() const;
-    void setUseQmlls(bool newUseQmlls);
-
-    bool useLatestQmlls() const;
-    void setUseLatestQmlls(bool newUseLatestQmlls);
-
-    bool ignoreMinimumQmllsVersion() const;
-    void setIgnoreMinimumQmllsVersion(bool newIgnoreMinimumQmllsVersion);
-
-    bool disableBuiltinCodemodel() const;
-    void setDisableBuiltinCodemodel(bool newDisableBuiltinCodemodel);
-
-    bool generateQmllsIniFiles() const;
-    void setGenerateQmllsIniFiles(bool newGenerateQmllsIniFiles);
-
-    friend bool operator==(const QmlJsEditingSettings &s1, const QmlJsEditingSettings &s2)
-    { return s1.equals(s2); }
-    friend bool operator!=(const QmlJsEditingSettings &s1, const QmlJsEditingSettings &s2)
-    { return !s1.equals(s2); }
-
-private:
-    bool m_enableContextPane = false;
-    bool m_pinContextPane = false;
-    bool m_autoFormatOnSave = false;
-    bool m_autoFormatOnlyCurrentProject = false;
-    bool m_foldAuxData = true;
-    bool m_useCustomFormatCommand = false;
-    bool m_useCustomAnalyzer = false;
-    bool m_useQmlls = true;
-    bool m_useLatestQmlls = false;
-    bool m_ignoreMinimumQmllsVersion = false;
-    bool m_disableBuiltinCodemodel = false;
-    bool m_generateQmllsIniFiles = false;
-    QString m_uiQmlOpenMode;
-    QString m_formatCommand;
-    QString m_formatCommandOptions;
-    QSet<int> m_disabledMessages;
-    QSet<int> m_disabledMessagesForNonQuickUi;
 };
 
 class QmllsSettingsManager : public QObject

src/plugins/qmljseditor/quicktoolbar.cpp

@@ -383,13 +383,13 @@ void QuickToolBar::onPropertyRemovedAndChange(const QString &remove, const QStri
 
 void QuickToolBar::onPinnedChanged(bool b)
 {
-    settings().setPinContextPane(b);
+    settings().pinContextPane.setValue(b);
 }
 
 void QuickToolBar::onEnabledChanged(bool b)
 {
-    settings().setPinContextPane(b);
+    settings().pinContextPane.setValue(b);
-    settings().setEnableContextPane(b);
+    settings().enableContextPane.setValue(b);
 }
 
 void QuickToolBar::indentLines(int startLine, int endLine)