cosmetics

Author: yuygfgg

llvmexpr/analysis/passes/PropWriteTypeSafetyPass.cpp

@@ -44,19 +44,20 @@ PropWriteTypeSafetyPass::run(const std::vector<Token>& tokens,
 
             auto it = prop_types.find(prop_name);
             if (it != prop_types.end()) {
-                auto& [stored_type, stored_idx] = it->second;
+                auto& stored_type = it->second.first;
                 if (stored_type != prop_type) {
                     // DELETE can co-exist with other types.
                     if (stored_type == PropWriteType::Delete) {
                         stored_type = prop_type;
-                        stored_idx = static_cast<int>(i);
+                        it->second.second = static_cast<int>(i);
                     } else if (prop_type != PropWriteType::Delete) {
                         throw AnalysisError(
                             std::format(
                                 "Inconsistent types used for property '{}'. "
                                 "Previous type: {} (idx: {}), current type: {} "
                                 "(idx: {}).",
-                                prop_name, enum_name(stored_type), stored_idx,
+                                prop_name, enum_name(stored_type),
+                                it->second.second,
                                 enum_name(prop_type), static_cast<int>(i)),
                             static_cast<int>(i));
                     }

llvmexpr/analysis/passes/StructurizeCFGPass.cpp

@@ -310,11 +310,8 @@ bool node_split_make_reducible(std::vector<CFGBlock>& cfg,
                     if (in_component[(size_t)p] != 0) {
                         continue; // keep SCC-internal edges pointing to original
                     }
-                    for (int& s : cfg[(size_t)p].successors) {
-                        if (s == entry) {
-                            s = entry_clone;
-                        }
-                    }
+                    std::ranges::replace(cfg[(size_t)p].successors, entry,
+                                         entry_clone);
                 }
             }
 
@@ -400,11 +397,7 @@ bool tail_duplicate_trivial_joins(std::vector<CFGBlock>& cfg,
             cfg.push_back(std::move(clone));
             origin_map.push_back(origin_map[(size_t)c]);
 
-            for (int& s : cfg[(size_t)p].successors) {
-                if (s == c) {
-                    s = clone_idx;
-                }
-            }
+            std::ranges::replace(cfg[(size_t)p].successors, c, clone_idx);
         }
 
         changed = true;

llvmexpr/codegen/glsl/GLSLGenerator.cpp

@@ -647,12 +647,13 @@ bool GLSLGenerator::canStructureFrom(int start_block, int stop_block,
         }
         [[nodiscard]] bool handleNonlocalEdge(int /*block*/, int next,
                                               int stop_block,
-                                              LoopContext& ctx) const {
+                                              const LoopContext& ctx) const {
             auto saved = ctx;
             return gen->canEdgeToBlock(next, stop_block, saved);
         }
-        bool handleBranch(int /*block*/, int t, int f, int join,
-                          int /*stop_block*/, LoopContext& ctx) const {
+        [[nodiscard]] bool handleBranch(int /*block*/, int t, int f, int join,
+                                        int /*stop_block*/,
+                                        const LoopContext& ctx) const {
             auto saved_t = ctx;
             auto saved_f = ctx;
             return gen->canEdgeToBlock(t, join, saved_t) &&

llvmexpr/frontend/Tokenizer.cpp

@@ -75,7 +75,7 @@ template <std::size_t N> struct FixedString {
     std::array<char, N> value;
 
     // NOLINTNEXTLINE(modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-    constexpr FixedString(const char (&str)[N]) {
+    explicit constexpr FixedString(const char (&str)[N]) {
         std::ranges::copy(str, value.begin());
     }
 

llvmexpr/frontend/infix2postfix/PostfixBuilder.cpp

@@ -21,6 +21,7 @@
 
 #include <cctype>
 #include <format>
+#include <numeric>
 #include <sstream>
 
 namespace infix2postfix {
@@ -236,10 +237,11 @@ std::string PostfixBuilder::get_expression() const {
         return "";
     }
 
-    size_t total_len = 0;
-    for (const auto& token : tokens) {
-        total_len += token.length();
-    }
+    size_t total_len =
+        std::accumulate(tokens.begin(), tokens.end(), size_t{0},
+                        [](size_t sum, const std::string& token) {
+                            return sum + token.length();
+                        });
     total_len += tokens.size() - 1; // for spaces
 
     std::string result;

llvmexpr/frontend/infix2postfix/SemanticAnalyzer.cpp

@@ -570,11 +570,11 @@ Type SemanticAnalyzer::analyze(CallExpr& expr) {
 
         auto it = written_properties.find(prop_name);
         if (it != written_properties.end()) {
-            auto& [stored_suffix, stored_range] = it->second;
+            auto& stored_suffix = it->second.first;
             if (stored_suffix != suffix) {
                 if (stored_suffix == "d") {
                     stored_suffix = suffix;
-                    stored_range = expr.range;
+                    it->second.second = expr.range;
                 } else if (suffix != "d") {
                     reportError(
                         std::format("Property '{}' is written with "

llvmexpr/runtime/vulkan/VulkanComputePipeline.cpp

@@ -21,6 +21,7 @@
 #include "VulkanContext.hpp"
 #include "VulkanMemory.hpp"
 
+#include <algorithm>
 #include <memory>
 #include <mutex>
 #include <shaderc/shaderc.hpp>
@@ -220,10 +221,9 @@ void VulkanComputePipeline::updateDescriptorSets(
 
     // Update cache
     cached_input_buffers.clear();
-    cached_input_buffers.reserve(input_buffers.size());
-    for (auto* buf : input_buffers) {
-        cached_input_buffers.push_back(buf->buffer);
-    }
+    cached_input_buffers.resize(input_buffers.size());
+    std::ranges::transform(input_buffers, cached_input_buffers.begin(),
+                           [](const auto* buf) { return buf->buffer; });
     cached_output_buffer = output_buffer.buffer;
     cached_props_buffer = new_props_buffer_handle;
 

llvmexpr/runtime/vulkan/VulkanContext.cpp

@@ -206,10 +206,8 @@ void VulkanContext::pickPhysicalDevice() {
         return;
     }
 
-    for (const auto& dev : devices) {
-        if (select_device(dev)) {
-            return;
-        }
+    if (std::ranges::any_of(devices, select_device)) {
+        return;
     }
 
     throw std::runtime_error(std::format(
@@ -226,11 +224,12 @@ void VulkanContext::createDevice() {
 
     std::vector<vk::ExtensionProperties> available_extensions =
         physical_device.enumerateDeviceExtensionProperties();
-    for (const auto& ext : available_extensions) {
-        if (strcmp(ext.extensionName, "VK_KHR_portability_subset") == 0) {
-            device_extensions.push_back("VK_KHR_portability_subset");
-            break;
-        }
+    const bool has_portability_subset = std::ranges::any_of(
+        available_extensions, [](const vk::ExtensionProperties& ext) {
+            return strcmp(ext.extensionName, "VK_KHR_portability_subset") == 0;
+        });
+    if (has_portability_subset) {
+        device_extensions.push_back("VK_KHR_portability_subset");
     }
 
     vk::DeviceCreateInfo create_info({}, queue_create_info,