Utils: Add sorted() function

For simpler calling code.

Change-Id: Ia0a16a28770fd172f74d06a626148248bf5d3c0c
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Christian Stenger <christian.stenger@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>

src/libs/modelinglib/qmt/style/defaultstyleengine.cpp

@@ -296,8 +296,7 @@ const Style *DefaultStyleEngine::applyObjectStyle(const Style *baseStyle, const
     }
     int depth = 0;
     if (!depths.isEmpty()) {
-        QList<int> keys = depths.keys();
+        const QList<int> keys = Utils::sorted(depths.keys());
-        Utils::sort(keys);
         foreach (int d, keys) {
             DepthProperties properties = depths.value(d);
             if (properties.m_elementType == elementType

src/libs/utils/algorithm.h

@@ -1005,6 +1005,48 @@ inline void sort(Container &container, Predicate p)
     std::stable_sort(std::begin(container), std::end(container), p);
 }
 
+template <typename Container>
+inline Container sorted(const Container &container)
+{
+    Container c = container;
+    sort(c);
+    return c;
+}
+
+template <typename Container>
+inline Container sorted(Container &&container)
+{
+    sort(container);
+    return container;
+}
+
+template <typename Container>
+inline Container sorted(const Container &&container)
+{
+    return sorted(container);
+}
+
+template <typename Container, typename Predicate>
+inline Container sorted(const Container &container, Predicate p)
+{
+    Container c = container;
+    sort(c, p);
+    return c;
+}
+
+template <typename Container, typename Predicate>
+inline Container sorted(Container &&container, Predicate p)
+{
+    sort(container, p);
+    return container;
+}
+
+template <typename Container, typename Predicate>
+inline Container sorted(const Container &&container, Predicate p)
+{
+    return sorted(container, p);
+}
+
 // pointer to member
 template <typename Container, typename R, typename S>
 inline void sort(Container &container, R S::*member)
@@ -1017,6 +1059,27 @@ inline void sort(Container &container, R S::*member)
     });
 }
 
+template <typename Container, typename R, typename S>
+inline Container sorted(const Container &container, R S::*member)
+{
+    Container c = container;
+    sort(c, member);
+    return c;
+}
+
+template <typename Container, typename R, typename S>
+inline Container sorted(Container &&container, R S::*member)
+{
+    sort(container, member);
+    return container;
+}
+
+template <typename Container, typename R, typename S>
+inline Container sorted(const Container &&container, R S::*member)
+{
+    return sorted(container, member);
+}
+
 // pointer to member function
 template <typename Container, typename R, typename S>
 inline void sort(Container &container, R (S::*function)() const)
@@ -1029,6 +1092,27 @@ inline void sort(Container &container, R (S::*function)() const)
     });
 }
 
+template <typename Container, typename R, typename S>
+inline Container sorted(const Container &container, R (S::*function)() const)
+{
+    Container c = container;
+    sort(c, function);
+    return c;
+}
+
+template <typename Container, typename R, typename S>
+inline Container sorted(Container &&container, R (S::*function)() const)
+{
+    sort(container, function);
+    return container;
+}
+
+template <typename Container, typename R, typename S>
+inline Container sorted(const Container &&container, R (S::*function)() const)
+{
+    return sorted(container, function);
+}
+
 //////////////////
 // reverseForeach
 /////////////////

src/libs/utils/codegeneration.cpp

@@ -62,9 +62,8 @@ QTCREATOR_UTILS_EXPORT void writeBeginQtVersionCheck(QTextStream &str)
 
 static void qtSection(const QStringList &qtIncludes, QTextStream &str)
 {
-    QStringList sorted = qtIncludes;
+    const QStringList sorted = Utils::sorted(qtIncludes);
-    sort(sorted);
+    for (const QString &inc : sorted) {
-    for (const QString &inc : std::as_const(sorted)) {
         if (!inc.isEmpty())
             str << QStringLiteral("#include <%1>\n").arg(inc);
     }

src/libs/utils/id.cpp

@@ -224,9 +224,7 @@ QSet<Id> Id::fromStringList(const QStringList &list)
 
 QStringList Id::toStringList(const QSet<Id> &ids)
 {
-    QList<Id> idList = toList(ids);
+    return transform(sorted(toList(ids)), &Id::toString);
-    sort(idList);
-    return transform(idList, &Id::toString);
 }
 
 /*!

src/libs/utils/multitextcursor.cpp

@@ -110,8 +110,7 @@ bool MultiTextCursor::hasSelection() const
 QString MultiTextCursor::selectedText() const
 {
     QString text;
-    QList<QTextCursor> cursors = m_cursors;
+    const QList<QTextCursor> cursors = Utils::sorted(m_cursors);
-    Utils::sort(cursors);
     for (const QTextCursor &cursor : cursors) {
         const QString &cursorText = cursor.selectedText();
         if (cursorText.isEmpty())
@@ -159,8 +158,7 @@ void MultiTextCursor::insertText(const QString &text, bool selectNewText)
             lines.pop_back();
         int index = 0;
         if (lines.count() == m_cursors.count()) {
-            QList<QTextCursor> cursors = m_cursors;
+            QList<QTextCursor> cursors = Utils::sorted(m_cursors);
-            Utils::sort(cursors);
             for (QTextCursor &cursor : cursors)
                 insertAndSelect(cursor, lines.at(index++), selectNewText);
             m_cursors.last().endEditBlock();

src/libs/utils/wizard.cpp

@@ -386,9 +386,8 @@ void Wizard::showVariables()
 {
     QString result = QLatin1String("<table>\n  <tr><td>Key</td><td>Type</td><td>Value</td><td>Eval</td></tr>\n");
     QHash<QString, QVariant> vars = variables();
-    QList<QString> keys = vars.keys();
+    const QList<QString> keys = sorted(vars.keys());
-    sort(keys);
+    for (const QString &key : keys) {
-    for (const QString &key : std::as_const(keys)) {
         const QVariant &v = vars.value(key);
         result += QLatin1String("  <tr><td>")
                 + key + QLatin1String("</td><td>")

src/plugins/android/androidconfigurations.cpp

@@ -395,8 +395,7 @@ static QList<int> availableNdkPlatformsImpl(const FilePath &ndkLocation, const A
     if (result.isEmpty())
         result = availableNdkPlatformsV21Plus(ndkLocation, abis, hostOs);
 
-    Utils::sort(result, std::greater<>());
+    return Utils::sorted(std::move(result), std::greater<>());
-    return result;
 }
 
 QList<int> AndroidConfig::availableNdkPlatforms(const QtVersion *qtVersion) const

src/plugins/android/androidmanifesteditorwidget.cpp

@@ -1553,8 +1553,7 @@ PermissionsModel::PermissionsModel(QObject *parent)
 void PermissionsModel::setPermissions(const QStringList &permissions)
 {
     beginResetModel();
-    m_permissions = permissions;
+    m_permissions = Utils::sorted(permissions);
-    Utils::sort(m_permissions);
     endResetModel();
 }
 

src/plugins/android/avdmanageroutputparser.cpp

@@ -127,9 +127,7 @@ AndroidDeviceInfoList parseAvdList(const QString &output, QStringList *avdErrorP
         }
     }
 
-    Utils::sort(avdList);
+    return Utils::sorted(std::move(avdList));
-
-    return avdList;
 }
 
 int platformNameToApiLevel(const QString &platformName)

src/plugins/autotest/projectsettingswidget.cpp

@@ -100,8 +100,8 @@ ProjectTestSettingsWidget::ProjectTestSettingsWidget(ProjectExplorer::Project *p
 void ProjectTestSettingsWidget::populateFrameworks(const QHash<ITestFramework *, bool> &frameworks,
                                                    const QHash<ITestTool *, bool> &testTools)
 {
-    TestFrameworks sortedFrameworks = frameworks.keys();
+    const TestFrameworks sortedFrameworks = Utils::sorted(frameworks.keys(),
-    Utils::sort(sortedFrameworks, &ITestFramework::priority);
+                                                          &ITestFramework::priority);
 
     auto generateItem = [this](ITestBase *frameworkOrTestTool, bool checked) {
         auto item = new QTreeWidgetItem(m_activeFrameworks, {frameworkOrTestTool->displayName()});
@@ -111,7 +111,7 @@ void ProjectTestSettingsWidget::populateFrameworks(const QHash<ITestFramework *,
         item->setData(0, BaseTypeRole, frameworkOrTestTool->type());
     };
 
-    for (ITestFramework *framework : std::as_const(sortedFrameworks))
+    for (ITestFramework *framework : sortedFrameworks)
         generateItem(framework, frameworks.value(framework));
 
     // FIXME: testTools aren't sorted and we cannot use priority here

src/plugins/autotest/testcodeparser.cpp

@@ -135,8 +135,8 @@ void TestCodeParser::updateTestTree(const QSet<ITestParser *> &parsers)
 
     m_postponedUpdateType = UpdateType::NoUpdate;
     qCDebug(LOG) << "calling scanForTests (updateTestTree)";
-    QList<ITestParser *> sortedParsers = Utils::toList(parsers);
+    const QList<ITestParser *> sortedParsers = Utils::sorted(Utils::toList(parsers),
-    Utils::sort(sortedParsers, [](const ITestParser *lhs, const ITestParser *rhs) {
+                [](const ITestParser *lhs, const ITestParser *rhs) {
         return lhs->framework()->priority() < rhs->framework()->priority();
     });
     scanForTests(Utils::FilePaths(), sortedParsers);

src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp

@@ -110,10 +110,9 @@ void PreconfiguredSessionTests::testPreconfiguredSession()
 
 static const QList<Project *> validProjects(const QList<Project *> projectsOfSession)
 {
-    QList<Project *> sortedProjects = projectsOfSession;
+    const QList<Project *> sortedProjects = Utils::sorted(projectsOfSession,
-    Utils::sort(sortedProjects, [](Project *lhs, Project *rhs){
+                [](Project *lhs, Project *rhs) {  return lhs->displayName() < rhs->displayName(); }
-        return lhs->displayName() < rhs->displayName();
+    );
-    });
 
     const auto isValidProject = [](Project *project) {
         const QList <Target *> targets = project->targets();
@@ -129,10 +128,9 @@ static const QList<Project *> validProjects(const QList<Project *> projectsOfSes
 
 static QList<Target *> validTargets(Project *project)
 {
-    QList<Target *> sortedTargets = project->targets();
+    const QList<Target *> sortedTargets = Utils::sorted(project->targets(),
-    Utils::sort(sortedTargets, [](Target *lhs, Target *rhs){
+                [](Target *lhs, Target *rhs) { return lhs->displayName() < rhs->displayName(); }
-        return lhs->displayName() < rhs->displayName();
+    );
-    });
 
     const QString projectFileName = project->projectFilePath().fileName();
     const auto isValidTarget = [projectFileName](Target *target) {

src/plugins/clangtools/filterdialog.cpp

@@ -50,14 +50,13 @@ class FilterChecksModel : public Utils::TreeModel<Utils::TreeItem, CheckItem>
 public:
     FilterChecksModel(const Checks &checks)
     {
-        Checks sortedChecks = checks;
+        const Checks sortedChecks = Utils::sorted(checks, [](const Check &lhs, const Check &rhs) {
-        Utils::sort(sortedChecks, [](const Check &lhs, const Check &rhs) {
             return lhs.displayName < rhs.displayName;
         });
 
         setHeader({tr("Check"), "#"});
         setRootItem(new Utils::StaticTreeItem(QString()));
-        for (const Check &check : std::as_const(sortedChecks))
+        for (const Check &check : sortedChecks)
             m_root->appendChild(new CheckItem(check));
     }
 };

src/plugins/cmakeprojectmanager/cmakeconfigitem.cpp

@@ -389,9 +389,7 @@ CMakeConfig CMakeConfig::fromFile(const Utils::FilePath &cacheFile, QString *err
         }
     }
 
-    Utils::sort(result, &CMakeConfigItem::less);
+    return Utils::sorted(std::move(result), &CMakeConfigItem::less);
-
-    return result;
 }
 
 QString CMakeConfigItem::toString(const Utils::MacroExpander *expander) const

src/plugins/cmakeprojectmanager/cmakekitinformation.cpp

@@ -433,8 +433,8 @@ private:
 
         cmakeLabel->setText(m_currentTool->cmakeExecutable().toUserOutput());
 
-        QList<CMakeTool::Generator> generatorList = m_currentTool->supportedGenerators();
+        const QList<CMakeTool::Generator> generatorList = Utils::sorted(
-        Utils::sort(generatorList, &CMakeTool::Generator::name);
+                    m_currentTool->supportedGenerators(), &CMakeTool::Generator::name);
 
         for (auto it = generatorList.constBegin(); it != generatorList.constEnd(); ++it)
             generatorCombo->addItem(it->name);

src/plugins/cmakeprojectmanager/cmaketool.cpp

@@ -459,8 +459,8 @@ void CMakeTool::parseFunctionDetailsOutput(const QString &output)
                 if (!words.isEmpty()) {
                     const QString command = words.takeFirst();
                     if (functionSet.contains(command)) {
-                        QStringList tmp = words + m_introspection->m_functionArgs[command];
+                        const QStringList tmp = Utils::sorted(
-                        Utils::sort(tmp);
+                                    words + m_introspection->m_functionArgs[command]);
                         m_introspection->m_functionArgs[command] = Utils::filteredUnique(tmp);
                     }
                 }

src/plugins/coreplugin/dialogs/codecselector.cpp

@@ -52,13 +52,12 @@ CodecSelector::CodecSelector(QWidget *parent, Core::BaseTextDocument *doc)
 
     QStringList encodings;
 
-    QList<int> mibs = QTextCodec::availableMibs();
+    const QList<int> mibs = Utils::sorted(QTextCodec::availableMibs());
-    Utils::sort(mibs);
     QList<int> sortedMibs;
-    for (const int mib : std::as_const(mibs))
+    for (const int mib : mibs)
         if (mib >= 0)
             sortedMibs += mib;
-    for (const int mib : std::as_const(mibs))
+    for (const int mib : mibs)
         if (mib < 0)
             sortedMibs += mib;
 

src/plugins/coreplugin/editormanager/editormanager.cpp

@@ -1709,8 +1709,8 @@ bool EditorManagerPrivate::closeEditors(const QList<IEditor*> &editors, CloseFla
     // When handling the last view in the list we handle the case where all
     // visible editors are closed, and we need to e.g. revive an invisible or
     // a suspended editor
-    QList<EditorView *> views = editorsPerView.keys();
+    const QList<EditorView *> views = Utils::sorted(editorsPerView.keys(),
-    Utils::sort(views, [editorsPerView, currentView](EditorView *a, EditorView *b) {
+                [editorsPerView, currentView](EditorView *a, EditorView *b) {
         if (a == b)
             return false;
         const bool aHasCurrent = editorsPerView.values(a).contains(a->currentEditor());
@@ -1723,7 +1723,7 @@ bool EditorManagerPrivate::closeEditors(const QList<IEditor*> &editors, CloseFla
             return true;
         return false;
     });
-    for (EditorView *view : std::as_const(views)) {
+    for (EditorView *view : views) {
         QList<IEditor *> editors = editorsPerView.values(view);
         // handle current editor in view last
         IEditor *viewCurrentEditor = view->currentEditor();

src/plugins/coreplugin/find/basetextfind.cpp

@@ -438,8 +438,7 @@ void BaseTextFind::defineFindScope()
     for (const QTextCursor &c : multiCursor) {
         if (c.hasSelection()) {
             if (foundSelection || c.block() != c.document()->findBlock(c.anchor())) {
-                QList<QTextCursor> sortedCursors = multiCursor.cursors();
+                const QList<QTextCursor> sortedCursors = Utils::sorted(multiCursor.cursors());
-                Utils::sort(sortedCursors);
                 d->m_scope = Utils::MultiTextCursor(sortedCursors);
                 QTextCursor cursor = textCursor();
                 cursor.clearSelection();

src/plugins/coreplugin/find/findplugin.cpp

@@ -299,9 +299,9 @@ void FindPrivate::setupFilterMenuItems()
     ActionContainer *mfindadvanced = ActionManager::actionContainer(Constants::M_FIND_ADVANCED);
     bool haveEnabledFilters = false;
     const Id base("FindFilter.");
-    QList<IFindFilter *> sortedFilters = IFindFilter::allFindFilters();
+    const QList<IFindFilter *> sortedFilters = Utils::sorted(IFindFilter::allFindFilters(),
-    Utils::sort(sortedFilters, &IFindFilter::displayName);
+                                                             &IFindFilter::displayName);
-    for (IFindFilter *filter : std::as_const(sortedFilters)) {
+    for (IFindFilter *filter : sortedFilters) {
         QAction *action = new QAction(filterActionName(filter), this);
         bool isEnabled = filter->isEnabled();
         if (isEnabled)

src/plugins/coreplugin/generalsettings.cpp

@@ -244,9 +244,8 @@ void GeneralSettingsWidget::fillCodecBox() const
 {
     const QByteArray currentCodec = codecForLocale();
 
-    QByteArrayList codecs = QTextCodec::availableCodecs();
+    const QByteArrayList codecs = Utils::sorted(QTextCodec::availableCodecs());
-    Utils::sort(codecs);
+    for (const QByteArray &codec : codecs) {
-    for (const QByteArray &codec : std::as_const(codecs)) {
         m_codecBox->addItem(QString::fromLocal8Bit(codec));
         if (codec == currentCodec)
             m_codecBox->setCurrentIndex(m_codecBox->count() - 1);

src/plugins/coreplugin/locator/locator.cpp

@@ -126,8 +126,8 @@ void Locator::initialize()
 
 void Locator::extensionsInitialized()
 {
-    m_filters = ILocatorFilter::allLocatorFilters();
+    m_filters = Utils::sorted(ILocatorFilter::allLocatorFilters(),
-    Utils::sort(m_filters, [](const ILocatorFilter *first, const ILocatorFilter *second) -> bool {
+                [](const ILocatorFilter *first, const ILocatorFilter *second) -> bool {
         if (first->priority() != second->priority())
             return first->priority() < second->priority();
         return first->id().alphabeticallyBefore(second->id());

src/plugins/coreplugin/mimetypesettings.cpp

@@ -196,9 +196,9 @@ Qt::ItemFlags MimeTypeSettingsModel::flags(const QModelIndex &index) const
 void MimeTypeSettingsModel::load()
 {
     beginResetModel();
-    m_mimeTypes = Utils::allMimeTypes();
     m_userDefault = Core::Internal::userPreferredEditorTypes();
-    Utils::sort(m_mimeTypes, [](const Utils::MimeType &a, const Utils::MimeType &b) {
+    m_mimeTypes = Utils::sorted(Utils::allMimeTypes(),
+                                [](const Utils::MimeType &a, const Utils::MimeType &b) {
         return a.name().compare(b.name(), Qt::CaseInsensitive) < 0;
     });
     m_handlersByMimeType.clear();

src/plugins/coreplugin/sidebarwidget.cpp

@@ -64,11 +64,10 @@ SideBarWidget::SideBarWidget(SideBar *sideBar, const QString &id)
     setLayout(lay);
     lay->addWidget(m_toolbar);
 
-    QStringList titleList = m_sideBar->availableItemTitles();
+    const QStringList titleList = Utils::sorted(m_sideBar->availableItemTitles());
-    Utils::sort(titleList);
     QString t = id;
     if (!titleList.isEmpty()) {
-        for (const QString &itemTitle : std::as_const(titleList))
+        for (const QString &itemTitle : titleList)
             m_comboBox->addItem(itemTitle, m_sideBar->idForTitle(itemTitle));
 
         m_comboBox->setCurrentIndex(0);

src/plugins/cppeditor/cppparsecontext.cpp

@@ -60,8 +60,7 @@ void ParseContextModel::reset(const ProjectPartInfo &projectPartInfo)
 {
     // Sort
     m_hints = projectPartInfo.hints;
-    m_projectParts = projectPartInfo.projectParts;
+    m_projectParts = Utils::sorted(projectPartInfo.projectParts, &ProjectPart::displayName);
-    Utils::sort(m_projectParts, &ProjectPart::displayName);
 
     // Determine index for current
     const QString id = projectPartInfo.projectPart->id();

src/plugins/cppeditor/cpptypehierarchy.cpp

@@ -53,13 +53,11 @@ QStandardItem *itemForClass(const CppClass &cppClass)
 
 QList<CppClass> sortClasses(const QList<CppClass> &cppClasses)
 {
-    QList<CppClass> sorted = cppClasses;
+    return sorted(cppClasses, [](const CppClass &c1, const CppClass &c2) -> bool {
-    sort(sorted, [](const CppClass &c1, const CppClass &c2) -> bool {
         const QString key1 = c1.name + QLatin1String("::") + c1.qualifiedName;
         const QString key2 = c2.name + QLatin1String("::") + c2.qualifiedName;
         return key1 < key2;
     });
-    return sorted;
 }
 
 } // Anonymous

src/plugins/cppeditor/includeutils.cpp

@@ -111,13 +111,13 @@ LineForNewIncludeDirective::LineForNewIncludeDirective(const QTextDocument *text
     , m_cppDocument(cppDocument)
     , m_includeStyle(includeStyle)
 {
-    QList<Document::Include> includes
+    const QList<Document::Include> includes = Utils::sorted(
-        = cppDocument->resolvedIncludes() + cppDocument->unresolvedIncludes();
+                cppDocument->resolvedIncludes() + cppDocument->unresolvedIncludes(),
-    Utils::sort(includes, &Include::line);
+                &Include::line);
 
     // Ignore *.moc includes if requested
     if (mocIncludeMode == IgnoreMocIncludes) {
-        for (const Document::Include &include : std::as_const(includes)) {
+        for (const Document::Include &include : includes) {
             if (!include.unresolvedFileName().endsWith(QLatin1String(".moc")))
                 m_includes << include;
         }

src/plugins/cppeditor/typehierarchybuilder_test.cpp

@@ -29,9 +29,9 @@ QString toString(const TypeHierarchy &hierarchy, int indent = 0)
     QString result = QString(indent, QLatin1Char(' '))
         + Overview().prettyName(symbol->name()) + QLatin1Char('\n');
 
-    QList<TypeHierarchy> sortedHierarchy = hierarchy.hierarchy();
     Overview oo;
-    Utils::sort(sortedHierarchy, [&oo](const TypeHierarchy &h1, const TypeHierarchy &h2) -> bool {
+    const QList<TypeHierarchy> sortedHierarchy = Utils::sorted(hierarchy.hierarchy(),
+            [&oo](const TypeHierarchy &h1, const TypeHierarchy &h2) -> bool {
         return oo.prettyName(h1.symbol()->name()) < oo.prettyName(h2.symbol()->name());
     });
     for (const TypeHierarchy &childHierarchy : std::as_const(sortedHierarchy))

src/plugins/debugger/gdb/gdbengine.cpp

@@ -794,10 +794,9 @@ int GdbEngine::commandTimeoutTime() const
 
 void GdbEngine::commandTimeout()
 {
-    QList<int> keys = m_commandForToken.keys();
+    const QList<int> keys = Utils::sorted(m_commandForToken.keys());
-    Utils::sort(keys);
     bool killIt = false;
-    for (int key : std::as_const(keys)) {
+    for (int key : keys) {
         const DebuggerCommand &cmd = m_commandForToken.value(key);
         killIt = true;
         showMessage(QString::number(key) + ": " + cmd.function);

src/plugins/git/stashdialog.cpp

@@ -372,8 +372,7 @@ QList<int> StashDialog::selectedRows() const
         if (index.isValid())
             rc.push_back(index.row());
     }
-    Utils::sort(rc);
+    return Utils::sorted(std::move(rc));
-    return rc;
 }
 
 void StashDialog::forceRefresh()

src/plugins/help/docsettingspage.cpp

@@ -326,11 +326,9 @@ void DocSettingsPageWidget::removeDocumentation(const QList<QModelIndex> &items)
     if (items.isEmpty())
         return;
 
-    QList<QModelIndex> itemsByDecreasingRow = items;
+    const QList<QModelIndex> itemsByDecreasingRow = Utils::sorted(items,
-    Utils::sort(itemsByDecreasingRow, [](const QModelIndex &i1, const QModelIndex &i2) {
+            [](const QModelIndex &i1, const QModelIndex &i2) { return i1.row() > i2.row(); });
-        return i1.row() > i2.row();
+    for (const QModelIndex &item : itemsByDecreasingRow) {
-    });
-    for (const QModelIndex &item : std::as_const(itemsByDecreasingRow)) {
         const int row = item.row();
         const QString nameSpace = m_model.entryAt(row).nameSpace;
 

src/plugins/languageclient/languageclientoutline.cpp

@@ -30,19 +30,15 @@ namespace LanguageClient {
 
 const QList<SymbolInformation> sortedSymbols(const QList<SymbolInformation> &symbols)
 {
-    auto result = symbols;
+    return Utils::sorted(symbols, [](const SymbolInformation &a, const SymbolInformation &b){
-    Utils::sort(result, [](const SymbolInformation &a, const SymbolInformation &b){
         return a.location().range().start() < b.location().range().start();
     });
-    return result;
 }
 const QList<DocumentSymbol> sortedSymbols(const QList<DocumentSymbol> &symbols)
 {
-    auto result = symbols;
+    return Utils::sorted(symbols, [](const DocumentSymbol &a, const DocumentSymbol &b){
-    Utils::sort(result, [](const DocumentSymbol &a, const DocumentSymbol &b){
         return a.range().start() < b.range().start();
     });
-    return result;
 }
 
 class LanguageClientOutlineItem : public Utils::TypedTreeItem<LanguageClientOutlineItem>

src/plugins/languageclient/semantichighlightsupport.cpp

@@ -352,14 +352,13 @@ void SemanticTokenSupport::handleSemanticTokensDelta(
         qCDebug(LOGLSPHIGHLIGHT) << "New Data " << tokens->data();
     } else if (auto tokensDelta = std::get_if<SemanticTokensDelta>(&result)) {
         m_tokens[filePath].version = documentVersion;
-        QList<SemanticTokensEdit> edits = tokensDelta->edits();
+        const QList<SemanticTokensEdit> edits = Utils::sorted(tokensDelta->edits(),
+                                                              &SemanticTokensEdit::start);
         if (edits.isEmpty()) {
             highlight(filePath);
             return;
         }
 
-        Utils::sort(edits, &SemanticTokensEdit::start);
-
         SemanticTokens &tokens = m_tokens[filePath].tokens;
         const QList<int> &data = tokens.data();
 

src/plugins/projectexplorer/kit.cpp

@@ -256,9 +256,8 @@ Tasks Kit::validate() const
     d->m_hasError = containsType(result, Task::TaskType::Error);
     d->m_hasWarning = containsType(result, Task::TaskType::Warning);
 
-    Utils::sort(result);
     d->m_hasValidityInfo = true;
-    return result;
+    return Utils::sorted(std::move(result));
 }
 
 void Kit::fix()

src/plugins/projectexplorer/kitinformation.cpp

@@ -200,8 +200,7 @@ public:
         layout->setContentsMargins(0, 0, 0, 0);
         layout->setColumnStretch(1, 2);
 
-        QList<Id> languageList = ToolChainManager::allLanguages();
+        const QList<Id> languageList = sorted(ToolChainManager::allLanguages(), [](Id l1, Id l2) {
-        sort(languageList, [](Id l1, Id l2) {
             return ToolChainManager::displayNameOfLanguageId(l1)
                     < ToolChainManager::displayNameOfLanguageId(l2);
         });
@@ -1449,9 +1448,8 @@ private:
             }
         }
 
-        sort(changes, [](const EnvironmentItem &lhs, const EnvironmentItem &rhs)
+        return sorted(std::move(changes), [](const EnvironmentItem &lhs, const EnvironmentItem &rhs)
         { return QString::localeAwareCompare(lhs.name, rhs.name) < 0; });
-        return changes;
     }
 
     void initMSVCOutputSwitch(QVBoxLayout *layout)

src/plugins/projectexplorer/makestep.cpp

@@ -144,9 +144,8 @@ QString MakeStep::defaultDisplayName()
 
 static const QList<ToolChain *> preferredToolChains(const Kit *kit)
 {
-    QList<ToolChain *> tcs = ToolChainKitAspect::toolChains(kit);
     // prefer CXX, then C, then others
-    Utils::sort(tcs, [](ToolChain *tcA, ToolChain *tcB) {
+    return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](ToolChain *tcA, ToolChain *tcB) {
         if (tcA->language() == tcB->language())
             return false;
         if (tcA->language() == Constants::CXX_LANGUAGE_ID)
@@ -157,7 +156,6 @@ static const QList<ToolChain *> preferredToolChains(const Kit *kit)
             return true;
         return false;
     });
-    return tcs;
 }
 
 FilePath MakeStep::defaultMakeCommand() const

src/plugins/projectexplorer/projectnodes.cpp

@@ -723,8 +723,7 @@ void FolderNode::setIcon(const IconCreator &iconCreator)
 
 void FolderNode::setLocationInfo(const QVector<FolderNode::LocationInfo> &info)
 {
-    m_locations = info;
+    m_locations = Utils::sorted(info, &LocationInfo::priority);
-    Utils::sort(m_locations, &LocationInfo::priority);
 }
 
 const QVector<FolderNode::LocationInfo> FolderNode::locationInfo() const

src/plugins/projectexplorer/targetsetuppage.cpp

@@ -463,11 +463,9 @@ bool TargetSetupPage::compareKits(const Kit *k1, const Kit *k2)
 
 std::vector<TargetSetupWidget *> TargetSetupPage::sortedWidgetList() const
 {
-    std::vector<TargetSetupWidget *> list = m_widgets;
+    return sorted(m_widgets, [](const TargetSetupWidget *w1, const TargetSetupWidget *w2) {
-    sort(list, [](const TargetSetupWidget *w1, const TargetSetupWidget *w2) {
         return compareKits(w1->kit(), w2->kit());
     });
-    return list;
 }
 
 void TargetSetupPage::openOptions()

src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp

@@ -271,12 +271,11 @@ void QmakeBuildConfiguration::updateProblemLabel()
         allGood = false;
 
     if (allGood) {
-        Tasks issues = version->reportIssues(proFileName, buildDirectory().toString());
+        const Tasks issues = Utils::sorted(
-        Utils::sort(issues);
+                    version->reportIssues(proFileName, buildDirectory().toString()));
-
         if (!issues.isEmpty()) {
             QString text = QLatin1String("<nobr>");
-            for (const ProjectExplorer::Task &task : std::as_const(issues)) {
+            for (const ProjectExplorer::Task &task : issues) {
                 QString type;
                 switch (task.type) {
                 case ProjectExplorer::Task::Error:

src/plugins/qmakeprojectmanager/qmakestep.cpp

@@ -243,12 +243,11 @@ bool QMakeStep::init()
     QTC_ASSERT(node, return false);
     QString proFile = node->filePath().toString();
 
-    Tasks tasks = qtVersion->reportIssues(proFile, workingDirectory.toString());
+    const Tasks tasks = Utils::sorted(
-    Utils::sort(tasks);
+                qtVersion->reportIssues(proFile, workingDirectory.toString()));
-
     if (!tasks.isEmpty()) {
         bool canContinue = true;
-        for (const Task &t : std::as_const(tasks)) {
+        for (const Task &t : tasks) {
             emit addTask(t);
             if (t.type == Task::Error)
                 canContinue = false;

src/plugins/qmljseditor/qmljseditor.cpp

@@ -351,13 +351,14 @@ void QmlJSEditorWidget::updateUses()
         return;
 
     QList<QTextEdit::ExtraSelection> selections;
-    QList<SourceLocation> locations
+
-            = m_qmlJsEditorDocument->semanticInfo().idLocations.value(wordUnderCursor());
     // code model may present the locations not in a document order
-    Utils::sort(locations, [](const SourceLocation &lhs, const SourceLocation &rhs) {
+    const QList<SourceLocation> locations = Utils::sorted(
+                m_qmlJsEditorDocument->semanticInfo().idLocations.value(wordUnderCursor()),
+                [](const SourceLocation &lhs, const SourceLocation &rhs) {
         return lhs.begin() < rhs.begin();
     });
-    for (const SourceLocation &loc : std::as_const(locations)) {
+    for (const SourceLocation &loc : locations) {
         if (! loc.isValid())
             continue;
 

src/plugins/qnx/qnxdeviceprocesslist.cpp

@@ -53,8 +53,7 @@ QList<ProcessInfo> QnxDeviceProcessList::buildProcessList(const QString &listPro
         }
     }
 
-    Utils::sort(processes);
+    return Utils::sorted(std::move(processes));
-    return processes;
 }
 
 } // Qnx::Internal

src/plugins/qnx/qnxtoolchain.cpp

@@ -67,10 +67,8 @@ static Abis detectTargetAbis(const FilePath &sdpPath)
             result.append(target.m_abi);
     }
 
-    Utils::sort(result,
+    return Utils::sorted(std::move(result),
               [](const Abi &arg1, const Abi &arg2) { return arg1.toString() < arg2.toString(); });
-
-    return result;
 }
 
 static void setQnxEnvironment(Environment &env, const EnvironmentItems &qnxEnv)

src/plugins/qtsupport/baseqtversion.cpp

@@ -874,8 +874,7 @@ QString QtVersion::toHtml(bool verbose) const
         if (verbose) {
             const QHash<ProKey, ProString> vInfo = d->versionInfo();
             if (!vInfo.isEmpty()) {
-                QList<ProKey> keys = vInfo.keys();
+                const QList<ProKey> keys = Utils::sorted(vInfo.keys());
-                Utils::sort(keys);
                 foreach (const ProKey &key, keys) {
                     const QString &value = vInfo.value(key).toQString();
                     QString variableName = key.toQString();
@@ -1685,9 +1684,7 @@ bool QtVersion::supportsMultipleQtAbis() const
 
 Tasks QtVersion::reportIssues(const QString &proFile, const QString &buildDir) const
 {
-    Tasks results = reportIssuesImpl(proFile, buildDir);
+    return Utils::sorted(reportIssuesImpl(proFile, buildDir));
-    Utils::sort(results);
-    return results;
 }
 
 QtConfigWidget *QtVersion::createConfigurationWidget() const
@@ -2274,8 +2271,8 @@ QtVersion *QtVersionFactory::createQtVersionFromQMakePath
     ProFileEvaluator evaluator(&globals, &parser, &vfs, &msgHandler);
     evaluator.loadNamedSpec(mkspec.path(), false);
 
-    QList<QtVersionFactory *> factories = g_qtVersionFactories;
+    const QList<QtVersionFactory *> factories = Utils::sorted(g_qtVersionFactories,
-    Utils::sort(factories, [](const QtVersionFactory *l, const QtVersionFactory *r) {
+            [](const QtVersionFactory *l, const QtVersionFactory *r) {
         return l->m_priority > r->m_priority;
     });
 

src/plugins/qtsupport/qtversionmanager.cpp

@@ -537,9 +537,7 @@ QtVersions QtVersionManager::versions(const QtVersion::Predicate &predicate)
 
 QtVersions QtVersionManager::sortVersions(const QtVersions &input)
 {
-    QtVersions result = input;
+    return Utils::sorted(input, qtVersionNumberCompare);
-    Utils::sort(result, qtVersionNumberCompare);
-    return result;
 }
 
 QtVersion *QtVersionManager::version(int id)
@@ -566,8 +564,7 @@ void QtVersionManager::setNewQtVersions(const QtVersions &newVersions)
 {
     // We want to preserve the same order as in the settings dialog
     // so we sort a copy
-    QtVersions sortedNewVersions = newVersions;
+    const QtVersions sortedNewVersions = Utils::sorted(newVersions, &QtVersion::uniqueId);
-    Utils::sort(sortedNewVersions, &QtVersion::uniqueId);
 
     QtVersions addedVersions;
     QtVersions removedVersions;

src/plugins/remotelinux/linuxdevice.cpp

@@ -340,8 +340,7 @@ private:
             processes.append(process);
         }
 
-        Utils::sort(processes);
+        return Utils::sorted(std::move(processes));
-        return processes;
     }
 };
 
@@ -1150,8 +1149,7 @@ static FilePaths dirsToCreate(const FilesToTransfer &files)
             parentDir = parentDir.parentDir();
         }
     }
-    sort(dirs);
+    return sorted(std::move(dirs));
-    return dirs;
 }
 
 static QByteArray transferCommand(const FileTransferDirection direction, bool link)

src/plugins/squish/objectsmaptreeitem.cpp

@@ -85,12 +85,11 @@ QByteArray ObjectsMapTreeItem::propertiesToByteArray() const
         return propertiesContent();
 
     QByteArray result;
-    PropertyList properties = this->properties();
+    const PropertyList properties = sorted(this->properties(),
-    sort(properties,
          [](const Property &lhs, const Property &rhs) { return lhs.m_name < rhs.m_name; });
 
     result.append('{');
-    for (const Property &property : std::as_const(properties))
+    for (const Property &property : properties)
         result.append(property.toString().toUtf8()).append(' ');
     if (result.at(result.size() - 1) == ' ')
         result.chop(1);

src/plugins/texteditor/codeassist/keywordscompletionassist.cpp

@@ -26,10 +26,10 @@ namespace TextEditor {
 // --------------------------
 // Note: variables and functions must be sorted
 Keywords::Keywords(const QStringList &variables, const QStringList &functions, const QMap<QString, QStringList> &functionArgs)
-    : m_variables(variables), m_functions(functions), m_functionArgs(functionArgs)
+    : m_variables(Utils::sorted(variables)),
+      m_functions(Utils::sorted(functions)),
+      m_functionArgs(functionArgs)
 {
-    Utils::sort(m_variables);
-    Utils::sort(m_functions);
 }
 
 bool Keywords::isVariable(const QString &word) const

src/plugins/texteditor/codecchooser.cpp

@@ -22,8 +22,7 @@ namespace TextEditor {
 
 CodecChooser::CodecChooser(Filter filter)
 {
-    QList<int> mibs = QTextCodec::availableMibs();
+    QList<int> mibs = Utils::sorted(QTextCodec::availableMibs());
-    Utils::sort(mibs);
     QList<int>::iterator firstNonNegative =
         std::find_if(mibs.begin(), mibs.end(), [](int n) { return n >=0; });
     if (firstNonNegative != mibs.end())

src/plugins/texteditor/texteditor.cpp

@@ -7229,8 +7229,8 @@ void TextEditorWidget::autoIndent()
     MultiTextCursor cursor = multiTextCursor();
     cursor.beginEditBlock();
     // The order is important, since some indenter refer to previous indent positions.
-    QList<QTextCursor> cursors = cursor.cursors();
+    const QList<QTextCursor> cursors = Utils::sorted(cursor.cursors(),
-    Utils::sort(cursors, [](const QTextCursor &lhs, const QTextCursor &rhs) {
+            [](const QTextCursor &lhs, const QTextCursor &rhs) {
         return lhs.selectionStart() < rhs.selectionStart();
     });
     for (const QTextCursor &c : cursors)

src/plugins/valgrind/suppressiondialog.cpp

@@ -193,12 +193,12 @@ void SuppressionDialog::accept()
 
     m_settings->suppressions.addSuppressionFile(path);
 
-    QModelIndexList indices = m_view->selectionModel()->selectedRows();
+    const QModelIndexList indices = Utils::sorted(m_view->selectionModel()->selectedRows(),
-    Utils::sort(indices, [](const QModelIndex &l, const QModelIndex &r) {
+                                                  [](const QModelIndex &l, const QModelIndex &r) {
         return l.row() > r.row();
     });
     QAbstractItemModel *model = m_view->model();
-    for (const QModelIndex &index : std::as_const(indices)) {
+    for (const QModelIndex &index : indices) {
         bool removed = model->removeRow(index.row());
         QTC_ASSERT(removed, qt_noop());
         Q_UNUSED(removed)

tests/auto/algorithm/tst_algorithm.cpp

@@ -145,8 +145,7 @@ void tst_Algorithm::transform()
         Utils::sort(i2);
         QCOMPARE(i2, QList<int>({1, 3, 132}));
         QList<qsizetype> i3 = Utils::transform<QList>(strings, &QString::size);
-        Utils::sort(i3);
+        QCOMPARE(Utils::sorted(i3), QList<qsizetype>({1, 1, 3}));
-        QCOMPARE(i3, QList<qsizetype>({1, 1, 3}));
     }
     {
         const QList<Struct> list({4, 3, 2, 1, 2});
@@ -421,13 +420,11 @@ void tst_Algorithm::sort()
     // member function with pointers
     QList<QString> arr1({"12345", "3333", "22"});
     QList<QString *> s5({&arr1[0], &arr1[1], &arr1[2]});
-    Utils::sort(s5, &QString::size);
+    QCOMPARE(Utils::sorted(s5, &QString::size), QList<QString *>({&arr1[2], &arr1[1], &arr1[0]}));
-    QCOMPARE(s5, QList<QString *>({&arr1[2], &arr1[1], &arr1[0]}));
     // member with pointers
     QList<Struct> arr2({4, 1, 3});
     QList<Struct *> s6({&arr2[0], &arr2[1], &arr2[2]});
-    Utils::sort(s6, &Struct::member);
+    QCOMPARE(Utils::sorted(s6, &Struct::member), QList<Struct *>({&arr2[1], &arr2[2], &arr2[0]}));
-    QCOMPARE(s6, QList<Struct *>({&arr2[1], &arr2[2], &arr2[0]}));
     // std::array:
     std::array<int, 4> array = {{4, 10, 8, 1}};
     Utils::sort(array);