Attempt to make the code more readable by using a vector

Shopify · Aug 2, 2024 · 5827745 · 5827745
1 parent fcd8532
commit 5827745
Showing 1 changed file with 21 additions and 32 deletions.
diff --git a/main/pipeline/pipeline.cc b/main/pipeline/pipeline.cc
@@ -273,49 +273,38 @@ unique_ptr<parser::Node> convertPrismToSorbet(pm_node_t *node, pm_parser_t *pars
             auto paramsNode = reinterpret_cast<pm_parameters_node *>(node);
             pm_location_t *loc = &paramsNode->base.location;
 
-            auto requireds = absl::MakeSpan((&paramsNode->requireds)->nodes, (&paramsNode->requireds)->size);
-            auto optionals = absl::MakeSpan((&paramsNode->optionals)->nodes, (&paramsNode->optionals)->size);
-            auto keywords = absl::MakeSpan((&paramsNode->keywords)->nodes, (&paramsNode->keywords)->size);
+            auto requireds = &paramsNode->requireds;
+            auto optionals = &paramsNode->optionals;
+            auto rest = paramsNode->rest;
+            auto keywords = &paramsNode->keywords;
+            auto keywordRest = paramsNode->keyword_rest;
+            auto block = paramsNode->block;
 
-            parser::NodeVec params;
+            std::vector<pm_node *> allParams;
 
-            auto restSize = paramsNode->rest == nullptr ? 0 : 1;
-            auto kwrestSize = paramsNode->keyword_rest == nullptr ? 0 : 1;
-            auto blockSize = paramsNode->block == nullptr ? 0 : 1;
+            allParams.insert(allParams.end(), requireds->nodes, requireds->nodes + requireds->size);
+            allParams.insert(allParams.end(), optionals->nodes, optionals->nodes + optionals->size);
 
-            params.reserve(requireds.size() + optionals.size() + restSize + keywords.size() + kwrestSize + blockSize);
+            if (rest != nullptr)
+                allParams.push_back(rest);
 
-            for (auto &param : requireds) {
-                unique_ptr<parser::Node> sorbetParam = convertPrismToSorbet(param, parser, gs);
-                params.emplace_back(std::move(sorbetParam));
-            }
+            allParams.insert(allParams.end(), keywords->nodes, keywords->nodes + keywords->size);
 
-            for (auto &param : optionals) {
-                unique_ptr<parser::Node> sorbetParam = convertPrismToSorbet(param, parser, gs);
-                params.emplace_back(std::move(sorbetParam));
-            }
+            if (keywordRest != nullptr)
+                allParams.push_back(keywordRest);
+            if (block != nullptr)
+                allParams.push_back(reinterpret_cast<pm_node *>(block));
 
-            if (paramsNode->rest != nullptr) {
-                unique_ptr<parser::Node> rest = convertPrismToSorbet(paramsNode->rest, parser, gs);
-                params.emplace_back(std::move(rest));
-            }
+            absl::Span<pm_node *> paramSpan(allParams);
+
+            parser::NodeVec params;
+            params.reserve(paramSpan.size());
 
-            for (auto &param : keywords) {
+            for (auto *param : paramSpan) {
                 unique_ptr<parser::Node> sorbetParam = convertPrismToSorbet(param, parser, gs);
                 params.emplace_back(std::move(sorbetParam));
             }
 
-            if (paramsNode->keyword_rest != nullptr) {
-                unique_ptr<parser::Node> keywordRest = convertPrismToSorbet(paramsNode->keyword_rest, parser, gs);
-                params.emplace_back(std::move(keywordRest));
-            }
-
-            if (paramsNode->block != nullptr) {
-                unique_ptr<parser::Node> block =
-                    convertPrismToSorbet(reinterpret_cast<pm_node *>(paramsNode->block), parser, gs);
-                params.emplace_back(std::move(block));
-            }
-
             return make_unique<parser::Args>(locOffset(loc, parser), std::move(params));
         }
         case PM_PROGRAM_NODE: {