search: use a struct for tracking components

We'll need this for link only components

Author: dcbaker

src/cps/search.cpp

@@ -31,6 +31,11 @@ namespace cps::search {
 
         using version::to_string;
 
+        struct Component {
+            std::string name;
+            bool link_only;
+        };
+
         /// @brief A CPS file, along with the components in that CPS file to
         /// load
         class Dependency {
@@ -40,7 +45,7 @@ namespace cps::search {
             /// @brief The loaded CPS file
             loader::Package package;
             /// @brief the components from that CPS file to use
-            std::vector<std::string> components;
+            std::vector<Component> components;
         };
 
         /// @brief A DAG node
@@ -377,64 +382,79 @@ namespace cps::search {
         /// @param node The node to process
         /// @param components the components required from this node
         void set_components(std::shared_ptr<Node> node, const std::vector<std::string> & components,
-                            bool default_components) {
-            // If this package needs the default_components, then add to the list of used components
+                            bool default_components, bool link_only = false) {
+            // Set the components that this package's dependees want
             if (default_components && node->data.package.default_components) {
                 const std::vector<std::string> & defs = node->data.package.default_components.value();
-                node->data.components.insert(node->data.components.end(), defs.begin(), defs.end());
+                std::transform(defs.begin(), defs.end(), std::back_insert_iterator(node->data.components),
+                               [link_only](std::string name) {
+                                   return Component{std::move(name), link_only};
+                               });
             }
             // Then add all of the explicitly listed components
-            node->data.components.insert(node->data.components.end(), components.begin(), components.end());
+            std::transform(components.begin(), components.end(), std::back_insert_iterator(node->data.components),
+                           [link_only](std::string name) {
+                               return Component{std::move(name), link_only};
+                           });
 
             // Handle self requirements first
             // This takes the form `"requires": [":a", ":b"]`
             // These must be handled before child dependencies, as they may alter the requirements placed on the
             // children..
-            std::vector<std::string> self_requires = node->data.components;
+            std::vector<Component> self_requires = node->data.components;
             std::unordered_set<std::string> processed;
             bool self_defaults = default_components;
             while (!self_requires.empty()) {
-                const std::string c_name = self_requires.back();
+                const Component this_comp = self_requires.back();
                 self_requires.pop_back();
-                if (processed.find(c_name) != processed.end()) {
+                if (processed.find(this_comp.name) != processed.end()) {
                     continue;
                 }
-                processed.emplace(c_name);
+                processed.emplace(this_comp.name);
 
-                const loader::Component & component = node->data.package.components.at(c_name);
+                const loader::Component & component = node->data.package.components.at(this_comp.name);
                 auto && required = process_requires(component.require);
                 if (auto && self = required.find(""); self != required.end()) {
                     // Don't insert these twice
                     if (!self_defaults && self->second.defaults && node->data.package.default_components) {
                         self_defaults = true;
                         const std::vector<std::string> & defs = node->data.package.default_components.value();
-                        node->data.components.insert(node->data.components.end(), defs.begin(), defs.end());
+                        std::transform(defs.begin(), defs.end(), std::back_insert_iterator(node->data.components),
+                                       [](std::string name) { return Component{std::move(name)}; });
                     }
                     for (auto && comp : self->second.components) {
                         if (processed.find(comp) != processed.end()) {
                             continue;
                         }
-                        self_requires.emplace_back(comp);
-                        node->data.components.emplace_back(comp);
+                        self_requires.emplace_back(Component{comp});
+                        node->data.components.emplace_back(Component{comp});
                     }
                 }
             }
 
             // Walk the list of components for this component, adding component
             // requirements recursively for external requirements.
-            for (const std::string & c_name : node->data.components) {
+            for (const Component & this_comp : node->data.components) {
                 // It's possible that the Package::Requires section listed
                 // dependencies we don't actually need. If we don't need them we
                 // can trim the graph
                 std::vector<std::shared_ptr<Node>> trimmed;
 
                 // This *should* be validated such that we won't have an exception
-                const loader::Component & component = node->data.package.components.at(c_name);
+                const loader::Component & component = node->data.package.components.at(this_comp.name);
                 auto && required = process_requires(component.require);
                 for (std::shared_ptr<Node> & child : node->depends) {
                     if (auto && child_comps = required.find(child->data.package.name); child_comps != required.end()) {
                         trimmed.emplace_back(child);
-                        set_components(child, child_comps->second.components, child_comps->second.defaults);
+                        set_components(child, child_comps->second.components, child_comps->second.defaults, link_only);
+                    }
+                }
+                auto && link_required = process_requires(component.link_requires);
+                for (std::shared_ptr<Node> & child : node->depends) {
+                    if (auto && child_comps = link_required.find(child->data.package.name);
+                        child_comps != link_required.end()) {
+                        trimmed.emplace_back(child);
+                        set_components(child, child_comps->second.components, child_comps->second.defaults, true);
                     }
                 }
                 node->depends = trimmed;
@@ -485,27 +505,30 @@ namespace cps::search {
                 return s;
             };
 
-            for (const auto & c_name : node->data.components) {
+            for (const Component & cps_comp : node->data.components) {
                 // We should have already errored if this is not the case
-                auto && f = node->data.package.components.find(c_name);
+                auto && f = node->data.package.components.find(cps_comp.name);
                 utils::assert_fn(
                     f != node->data.package.components.end(),
-                    fmt::format("Could not find component {} of package {}", c_name, node->data.package.name));
+                    fmt::format("Could not find component {} of package {}", cps_comp.name, node->data.package.name));
                 auto && comp = f->second;
 
                 // Convert prefix at this point because:
                 // 1. we are about to lose which CPS file the information came
                 // from
                 // 2. if we do it at the search point we have to plumb overrides
                 // deep into that
-                merge_result<loader::KnownLanguages, std::string>(comp.includes, result.includes, prefix_replacer);
-                merge_result(comp.definitions, result.definitions);
-                merge_result(comp.compile_flags, result.compile_flags);
+                if (!cps_comp.link_only) {
+                    merge_result<loader::KnownLanguages, std::string>(comp.includes, result.includes, prefix_replacer);
+                    merge_result(comp.definitions, result.definitions);
+                    merge_result(comp.compile_flags, result.compile_flags);
+                }
                 merge_result(comp.link_libraries, result.link_libraries);
                 merge_result(comp.link_flags, result.link_flags);
                 if (comp.type != loader::Type::interface) {
                     if (!comp.location) {
-                        return tl::make_unexpected(fmt::format("Component `{}` requires 'location' attribute", c_name));
+                        return tl::make_unexpected(
+                            fmt::format("Component `{}` requires 'location' attribute", cps_comp.name));
                     }
                     result.link_location.emplace_back(
                         prefix_replacer(comp.link_location.value_or(comp.location.value())));

tests/cases/cps-config.toml

@@ -133,3 +133,9 @@ name = "requires component from self nested"
 cps = "full"
 args = ["flags", "--component", "requires-self", "--cflags", "--print-errors"]
 expected = "-fvectorize -I/usr/local/include -I/opt/include -DBAR=2 -DFOO=1 -DOTHER"
+
+[[case]]
+name = "link requires nested"
+cps = "link-requires"
+args = ["flags", "--component", "nested", "--cflags", "--libs", "--print-errors"]
+expected = "-lfake"

tests/cases/pkg-config-compat.toml

@@ -59,3 +59,9 @@ name = "parsing pc file"
 cps = "pc-variables"
 args = ["pkg-config", "--cflags"]
 expected = "-I/home/kaniini/pkg/include/libfoo"
+
+[[case]]
+name = "link requires"
+cps = "link-requires"
+args = ["pkg-config", "--cflags", "--libs", "--print-errors"]
+expected = "-L/usr/lib/ -flto -l/something/lib/libfoo.so -lbar"

tests/cps-files/lib/cps/link-requires.cps

@@ -0,0 +1,27 @@
+{
+    "name": "link-requires",
+    "cps_version": "0.13.0",
+    "version": "1.0.0",
+    "requires": {
+        "full": null,
+        "multiple-components": null
+    },
+    "prefix": "/prefix",
+    "components": {
+        "default": {
+            "type": "interface",
+            "link_requires": [
+                "full"
+            ]
+        },
+        "nested": {
+            "type": "interface",
+            "link_requires": [
+                "multiple-components:link-requires"
+            ]
+        }
+    },
+    "default_components": [
+        "default"
+    ]
+}

tests/cps-files/lib/cps/multiple-components.cps

@@ -68,6 +68,12 @@
             "requires": [
                 "minimal:sample0"
             ]
+        },
+        "link-requires": {
+            "type": "interface",
+            "link_requires": [
+                "minimal:sample1"
+            ]
         }
     },
     "default_components": [