Meson: Replace most std::for_each by range based for

Change-Id: I18aa38bb84264e0f6a99f431c1caaded9bbbe248
Reviewed-by: hjk <hjk@qt.io>

src/plugins/mesonprojectmanager/mesoninfoparser/parsers/buildsystemfilesparser.h

@@ -65,12 +65,10 @@ public:
         auto arr = get<QJsonArray>(js.object(), "projectinfo", "buildsystem_files");
         appendFiles(arr, m_files);
         auto subprojects = get<QJsonArray>(js.object(), "projectinfo", "subprojects");
-        std::for_each(std::cbegin(*subprojects),
+        for (const auto &subproject : *subprojects) {
-                      std::cend(*subprojects),
+            auto arr = get<QJsonArray>(subproject.toObject(), "buildsystem_files");
-                      [this](const auto &subproject) {
+            appendFiles(arr, m_files);
-                          auto arr = get<QJsonArray>(subproject.toObject(), "buildsystem_files");
+        }
-                          appendFiles(arr, m_files);
-                      });
     }
 
     std::vector<Utils::FilePath> files() { return m_files; };

src/plugins/mesonprojectmanager/project/buildoptions/optionsmodel/buildoptionsmodel.cpp

@@ -55,17 +55,13 @@ inline void groupPerSubprojectAndSection(
     QMap<QString, QMap<QString, std::vector<CancellableOption *>>> &subprojectOptions,
     QMap<QString, std::vector<CancellableOption *>> &perSectionOptions)
 {
-    std::for_each(std::cbegin(options),
+    for (const std::unique_ptr<CancellableOption> &option : options) {
-                  std::cend(options),
+        if (option->subproject()) {
-                  [&subprojectOptions,
+            subprojectOptions[*option->subproject()][option->section()].push_back(option.get());
-                   &perSectionOptions](const std::unique_ptr<CancellableOption> &option) {
+        } else {
-                      if (option->subproject()) {
+            perSectionOptions[option->section()].push_back(option.get());
-                          subprojectOptions[*option->subproject()][option->section()].push_back(
+        }
-                              option.get());
+    }
-                      } else {
-                          perSectionOptions[option->section()].push_back(option.get());
-                      }
-                  });
 }
 
 void makeTree(Utils::TreeItem *root,
@@ -76,11 +72,9 @@ void makeTree(Utils::TreeItem *root,
                   [root](const std::pair<QString, std::vector<CancellableOption *>> kv) {
                       const auto &options = kv.second;
                       auto sectionNode = new Utils::StaticTreeItem(kv.first);
-                      std::for_each(std::cbegin(options),
+                      for (CancellableOption *option : options) {
-                                    std::cend(options),
+                          sectionNode->appendChild(makeBuildOptionTreeItem(option));
-                                    [sectionNode](CancellableOption *option) {
+                      }
-                                        sectionNode->appendChild(makeBuildOptionTreeItem(option));
-                                    });
                       root->appendChild(sectionNode);
                   });
 }
@@ -89,13 +83,10 @@ void BuidOptionsModel::setConfiguration(const BuildOptionsList &options)
 {
     clear();
     m_options = decltype(m_options)();
-    std::for_each(std::cbegin(options),
+    for (const BuildOptionsList::value_type &option : options) {
-                  std::cend(options),
+        m_options.emplace_back(
-                  [this](const BuildOptionsList::value_type &option) {
+            std::make_unique<CancellableOption>(option.get(), lockedOptions.contains(option->name)));
-                      m_options.emplace_back(
+    }
-                          std::make_unique<CancellableOption>(option.get(),
-                                                              lockedOptions.contains(option->name)));
-                  });
     {
         QMap<QString, QMap<QString, std::vector<CancellableOption *>>> subprojectOptions;
         QMap<QString, std::vector<CancellableOption *>> perSectionOptions;
@@ -106,8 +97,7 @@ void BuidOptionsModel::setConfiguration(const BuildOptionsList &options)
         std::for_each(subprojectOptions.constKeyValueBegin(),
                       subprojectOptions.constKeyValueEnd(),
                       [subProjects](
-                          const std::pair<QString, QMap<QString, std::vector<CancellableOption *>>>
+                          const std::pair<QString, QMap<QString, std::vector<CancellableOption *>>> kv) {
-                              kv) {
                           auto subProject = new Utils::StaticTreeItem{kv.first};
                           makeTree(subProject, kv.second);
                           subProjects->appendChild(subProject);
@@ -128,13 +118,11 @@ bool BuidOptionsModel::setData(const QModelIndex &idx, const QVariant &data, int
 QStringList BuidOptionsModel::changesAsMesonArgs()
 {
     QStringList args;
-    std::for_each(std::cbegin(m_options),
+    for (const std::unique_ptr<CancellableOption> &option : m_options) {
-                  std::cend(m_options),
+        if (option->hasChanged()) {
-                  [&](const std::unique_ptr<CancellableOption> &option) {
+            args.push_back(option->mesonArg());
-                      if (option->hasChanged()) {
+        }
-                          args.push_back(option->mesonArg());
+    }
-                      }
-                  });
     return args;
 }
 

src/plugins/mesonprojectmanager/project/mesonprojectparser.cpp

@@ -75,7 +75,7 @@ inline Utils::optional<ProjectExplorer::Macro> extractMacro(const QString &arg)
 CompilerArgs splitArgs(const QStringList &args)
 {
     CompilerArgs splited;
-    std::for_each(std::cbegin(args), std::cend(args), [&splited](const QString &arg) {
+    for (const QString &arg : args) {
         auto inc = extractInclude(arg);
         if (inc) {
             splited.includePaths << *inc;
@@ -87,7 +87,7 @@ CompilerArgs splitArgs(const QStringList &args)
                 splited.args << arg;
             }
         }
-    });
+    }
     return splited;
 }
 
@@ -198,22 +198,19 @@ bool MesonProjectParser::parse(const Utils::FilePath &sourcePath)
 QList<ProjectExplorer::BuildTargetInfo> MesonProjectParser::appsTargets() const
 {
     QList<ProjectExplorer::BuildTargetInfo> apps;
-    std::for_each(std::cbegin(m_parserResult.targets),
+    for (const Target &target : m_parserResult.targets) {
-                  std::cend(m_parserResult.targets),
+        if (target.type == Target::Type::executable) {
-                  [&apps, srcDir = m_srcDir](const Target &target) {
+            ProjectExplorer::BuildTargetInfo bti;
-                      if (target.type == Target::Type::executable) {
+            bti.displayName = target.name;
-                          ProjectExplorer::BuildTargetInfo bti;
+            bti.buildKey = Target::fullName(m_srcDir, target);
-                          bti.displayName = target.name;
+            bti.displayNameUniquifier = bti.buildKey;
-                          bti.buildKey = Target::fullName(srcDir, target);
+            bti.targetFilePath = Utils::FilePath::fromString(target.fileName.first());
-                          bti.displayNameUniquifier = bti.buildKey;
+            bti.workingDirectory = Utils::FilePath::fromString(target.fileName.first()).absolutePath();
-                          bti.targetFilePath = Utils::FilePath::fromString(target.fileName.first());
+            bti.projectFilePath = Utils::FilePath::fromString(target.definedIn);
-                          bti.workingDirectory
+            bti.usesTerminal = true;
-                              = Utils::FilePath::fromString(target.fileName.first()).absolutePath();
+            apps.append(bti);
-                          bti.projectFilePath = Utils::FilePath::fromString(target.definedIn);
+        }
-                          bti.usesTerminal = true;
+    }
-                          apps.append(bti);
-                      }
-                  });
     return apps;
 }
 bool MesonProjectParser::startParser()

src/plugins/mesonprojectmanager/project/ninjabuildstep.cpp

@@ -198,9 +198,9 @@ void NinjaBuildStep::setupOutputFormatter(Utils::OutputFormatter *formatter)
     m_ninjaParser->setSourceDirectory(project()->projectDirectory());
     formatter->addLineParser(m_ninjaParser);
     auto additionalParsers = kit()->createOutputParsers();
-    std::for_each(std::cbegin(additionalParsers),
+    for (const auto parser : additionalParsers) {
-                  std::cend(additionalParsers),
+        parser->setRedirectionDetector(m_ninjaParser);
-                  [this](const auto parser) { parser->setRedirectionDetector(m_ninjaParser); });
+    }
     formatter->addLineParsers(additionalParsers);
     formatter->addSearchDir(processParameters()->effectiveWorkingDirectory());
     AbstractProcessStep::setupOutputFormatter(formatter);

src/plugins/mesonprojectmanager/project/projecttree/projecttree.cpp

@@ -80,14 +80,11 @@ std::unique_ptr<MesonProjectNode> ProjectTree::buildTree(const Utils::FilePath &
     using namespace ProjectExplorer;
     std::set<Utils::FilePath> targetPaths;
     auto root = std::make_unique<MesonProjectNode>(srcDir);
-    std::for_each(std::cbegin(targets),
+    for (const Target &target : targets) {
-                  std::cend(targets),
+        buildTargetTree(root, target);
-                  [&root, &targetPaths](const Target &target) {
+        targetPaths.insert(Utils::FilePath::fromString(target.definedIn).absolutePath());
-                      buildTargetTree(root, target);
+        addTargetNode(root, target);
-                      targetPaths.insert(
+    }
-                          Utils::FilePath::fromString(target.definedIn).absolutePath());
-                      addTargetNode(root, target);
-                  });
     for (Utils::FilePath bsFile : bsFiles) {
         if (!bsFile.toFileInfo().isAbsolute())
             bsFile = srcDir.pathAppended(bsFile.toString());

src/plugins/mesonprojectmanager/settings/tools/kitaspect/toolkitaspectwidget.cpp

@@ -116,9 +116,9 @@ bool ToolKitAspectWidget::isCompatible(const MesonTools::Tool_t &tool)
 
 void ToolKitAspectWidget::loadTools()
 {
-    std::for_each(std::cbegin(MesonTools::tools()),
+    for (const MesonTools::Tool_t &tool : MesonTools::tools()) {
-                  std::cend(MesonTools::tools()),
+        addTool(tool);
-                  [this](const MesonTools::Tool_t &tool) { addTool(tool); });
+    }
     refresh();
     m_toolsComboBox->setEnabled(m_toolsComboBox->count());
 }

src/plugins/mesonprojectmanager/settings/tools/toolssettingsaccessor.cpp

@@ -59,20 +59,17 @@ void ToolsSettingsAccessor::saveMesonTools(const std::vector<MesonTools::Tool_t>
     using namespace Constants;
     QVariantMap data;
     int entry_count = 0;
-    std::for_each(std::cbegin(tools),
+    for (const MesonTools::Tool_t &tool : tools) {
-                  std::cend(tools),
+        auto asMeson = std::dynamic_pointer_cast<MesonWrapper>(tool);
-                  [&data, &entry_count](const MesonTools::Tool_t &tool) {
+        if (asMeson)
-                      auto asMeson = std::dynamic_pointer_cast<MesonWrapper>(tool);
+            data.insert(entryName(entry_count), toVariantMap<MesonWrapper>(*asMeson));
-                      if (asMeson)
+        else {
-                          data.insert(entryName(entry_count), toVariantMap<MesonWrapper>(*asMeson));
+            auto asNinja = std::dynamic_pointer_cast<NinjaWrapper>(tool);
-                      else {
+            if (asNinja)
-                          auto asNinja = std::dynamic_pointer_cast<NinjaWrapper>(tool);
+                data.insert(entryName(entry_count), toVariantMap<NinjaWrapper>(*asNinja));
-                          if (asNinja)
+        }
-                              data.insert(entryName(entry_count),
+        entry_count++;
-                                          toVariantMap<NinjaWrapper>(*asNinja));
+    }
-                      }
-                      entry_count++;
-                  });
     data.insert(ToolsSettings::ENTRY_COUNT, entry_count);
     saveSettings(data, parent);
 }