search: handle arbitrarily deep self requires references

This requires that all requirements of the current node be processed
before starting on any of its children, otherwise we may not select all
of the correct components from those children.

I still don't think the algorithm is fundamentally correct, since we
could still end up visiting the same child more than once, and could
fail to get all of the requirements we need for each child before
visiting it. However, this is an improvement over the status quo, and
does fix the linked issue.

Fixes: #101

Author: dcbaker

src/cps/search.cpp

@@ -378,13 +378,50 @@ namespace cps::search {
         /// @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) {
-            // Set the components that this package's depndees want
+            // If this package needs the default_components, then add to the list of used components
             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());
             }
+            // Then add all of the explicitly listed components
             node->data.components.insert(node->data.components.end(), components.begin(), components.end());
 
+            // 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::unordered_set<std::string> processed;
+            bool self_defaults = default_components;
+            while (!self_requires.empty()) {
+                const std::string c_name = self_requires.back();
+                self_requires.pop_back();
+                if (processed.find(c_name) != processed.end()) {
+                    continue;
+                }
+                processed.emplace(c_name);
+
+                const loader::Component & component = node->data.package.components.at(c_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());
+                    }
+                    for (auto && comp : self->second.components) {
+                        if (processed.find(comp) != processed.end()) {
+                            continue;
+                        }
+                        self_requires.emplace_back(comp);
+                        node->data.components.emplace_back(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) {
                 // It's possible that the Package::Requires section listed
                 // dependencies we don't actually need. If we don't need them we
@@ -401,16 +438,6 @@ namespace cps::search {
                     }
                 }
                 node->depends = trimmed;
-
-                if (auto && self = required.find(""); self != required.end()) {
-                    // Don't insert these twice
-                    if (!default_components && self->second.defaults && 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());
-                    }
-                    node->data.components.insert(node->data.components.end(), self->second.components.begin(),
-                                                 self->second.components.end());
-                }
             }
         }
 

tests/cases/cps-config.toml

@@ -123,7 +123,13 @@ args = ["flags", "--component", "star_values_override", "--cflags", "--print-err
 expected = "-fvectorize -I/usr/local/include -I/opt/include -DBAR=2 -DFOO=1 -DOTHER"
 
 [[case]]
-name = "Sets compat_version"
-cps = "needs-compat-version"
-args = ["flags", "--libs", "--print-errors"]
-expected = "-l/usr/lib/libfoo.a"
+name = "requires component from self"
+cps = "full"
+args = ["flags", "--component", "requires-self-helper", "--cflags", "--print-errors"]
+expected = "-fvectorize -I/usr/local/include -I/opt/include -DBAR=2 -DFOO=1 -DOTHER"
+
+[[case]]
+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"

tests/cps-files/lib/cps/full.cps

@@ -112,6 +112,20 @@
             },
             "location": "/something/lib/libfoo.so.1.2.0",
             "link_location": "/something/lib/libfoo.so"
+        },
+        "requires-self-helper": {
+            "type": "interface",
+            "requires": [
+                ":star_values"
+            ]
+        },
+        "requires-self": {
+            "type": "dylib",
+            "location": "/something/lib/libbar.so.1.8.1",
+            "link_location": "/something/lib/libbar.so",
+            "requires": [
+                ":requires-self-helper"
+            ]
         }
     },
     "default_components": [