Implement depend-defaults

include/vcpkg/base/jsonreader.h

@@ -160,6 +160,24 @@ namespace vcpkg::Json
             }
         }
 
+        // returns whether key \in obj
+        template<class Type>
+        bool optional_object_field(const Object& obj,
+                                   StringView key,
+                                   Optional<Type>& place,
+                                   IDeserializer<Type>& visitor)
+        {
+            if (auto value = obj.get(key))
+            {
+                visit_in_key(*value, key, place.emplace(), visitor);
+                return true;
+            }
+            else
+            {
+                return false;
+            }
+        }
+
         template<class Type>
         Optional<Type> visit(const Value& value, IDeserializer<Type>& visitor)
         {

include/vcpkg/dependencies.h

@@ -196,6 +196,12 @@ namespace vcpkg::Dependencies
                                    const StatusParagraphs& status_db,
                                    const CreateInstallPlanOptions& options = {Triplet{}});
 
+    enum class DependDefaults
+    {
+        NO,
+        YES,
+    };
+
     ExpectedS<ActionPlan> create_versioned_install_plan(const PortFileProvider::IVersionedPortfileProvider& vprovider,
                                                         const PortFileProvider::IBaselineProvider& bprovider,
                                                         const PortFileProvider::IOverlayProvider& oprovider,
@@ -204,7 +210,8 @@ namespace vcpkg::Dependencies
                                                         const std::vector<DependencyOverride>& overrides,
                                                         const PackageSpec& toplevel,
                                                         Triplet host_triplet,
-                                                        UnsupportedPortAction unsupported_port_action);
+                                                        UnsupportedPortAction unsupported_port_action,
+                                                        DependDefaults depend_defaults);
 
     void print_plan(const ActionPlan& action_plan, const bool is_recursive = true, const Path& builtin_ports_dir = {});
 }

include/vcpkg/packagespec.h

@@ -149,10 +149,14 @@ namespace vcpkg
     struct Dependency
     {
         std::string name;
+
+        // When created through parsing a manifest, `features` will be pre-normalized (containing 'core' and 'default'
+        // as appropriate)
         std::vector<std::string> features;
         PlatformExpression::Expr platform;
         DependencyConstraint constraint;
         bool host = false;
+        Optional<bool> default_features;
 
         Json::Object extra_info;
 

include/vcpkg/sourceparagraph.h

@@ -64,6 +64,7 @@ namespace vcpkg
         VersionScheme version_scheme = VersionScheme::String;
         std::string raw_version;
         int port_version = 0;
+        bool depend_defaults = true;
         std::vector<std::string> description;
         std::vector<std::string> summary;
         std::vector<std::string> maintainers;

src/vcpkg-test/dependencies.cpp

@@ -92,6 +92,8 @@ struct MockVersionedPortfileProvider : PortFileProvider::IVersionedPortfileProvi
     }
 };
 
+using Dependencies::DependDefaults;
+
 template<class T>
 T unwrap(ExpectedS<T> e)
 {
@@ -242,7 +244,8 @@ static ExpectedS<Dependencies::ActionPlan> create_versioned_install_plan(
                                                        overrides,
                                                        toplevel,
                                                        Test::ARM_UWP,
-                                                       Dependencies::UnsupportedPortAction::Error);
+                                                       Dependencies::UnsupportedPortAction::Error,
+                                                       DependDefaults::YES);
 }
 
 static ExpectedS<vcpkg::Dependencies::ActionPlan> create_versioned_install_plan(
@@ -262,7 +265,30 @@ static ExpectedS<vcpkg::Dependencies::ActionPlan> create_versioned_install_plan(
                                                               overrides,
                                                               toplevel,
                                                               Test::ARM_UWP,
-                                                              Dependencies::UnsupportedPortAction::Error);
+                                                              Dependencies::UnsupportedPortAction::Error,
+                                                              Dependencies::DependDefaults::YES);
+}
+
+static ExpectedS<vcpkg::Dependencies::ActionPlan> create_versioned_install_plan(
+    const PortFileProvider::IOverlayProvider& oprovider,
+    const std::vector<Dependency>& deps,
+    const PackageSpec& toplevel,
+    DependDefaults depend_defaults)
+{
+    MockVersionedPortfileProvider vp;
+    MockCMakeVarProvider var_provider;
+    MockBaselineProvider bp;
+
+    return vcpkg::Dependencies::create_versioned_install_plan(vp,
+                                                              bp,
+                                                              oprovider,
+                                                              var_provider,
+                                                              deps,
+                                                              {},
+                                                              toplevel,
+                                                              Test::ARM_UWP,
+                                                              Dependencies::UnsupportedPortAction::Error,
+                                                              depend_defaults);
 }
 
 TEST_CASE ("basic version install single", "[versionplan]")
@@ -1522,11 +1548,118 @@ TEST_CASE ("version install default features", "[versionplan]")
     MockBaselineProvider bp;
     bp.v["a"] = {"1", 0};
 
-    auto install_plan =
-        unwrap(create_versioned_install_plan(vp, bp, var_provider, {Dependency{"a"}}, {}, toplevel_spec()));
+    SECTION ("toplevel requires defaults")
+    {
+        auto install_plan =
+            unwrap(create_versioned_install_plan(vp, bp, var_provider, {Dependency{"a"}}, {}, toplevel_spec()));
 
-    REQUIRE(install_plan.size() == 1);
-    check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {"x"});
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {"x"});
+    }
+
+    SECTION ("default-features false")
+    {
+        auto install_plan = unwrap(create_versioned_install_plan(
+            vp, bp, var_provider, {Dependency{"a", {"core"}, {}, {}, false, false}}, {}, toplevel_spec()));
+
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {});
+    }
+
+    SECTION ("default-features true")
+    {
+        auto install_plan = unwrap(create_versioned_install_plan(
+            vp, bp, var_provider, {Dependency{"a", {"core", "default"}, {}, {}, false, false}}, {}, toplevel_spec()));
+
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {"x"});
+    }
+
+    SECTION ("default-features true 2")
+    {
+        auto install_plan = unwrap(create_versioned_install_plan(
+            vp, bp, var_provider, {Dependency{"a", {"core", "default"}, {}, {}, false, true}}, {}, toplevel_spec()));
+
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {"x"});
+    }
+}
+
+TEST_CASE ("version install depend-defaults", "[versionplan]")
+{
+    MockOverlayProvider op;
+    auto& a_scf = op.emplace("a");
+    a_scf.source_control_file->core_paragraph->dependencies.push_back(Dependency{"b"});
+    auto& b_scf = op.emplace("b");
+    b_scf.source_control_file->core_paragraph->default_features.emplace_back("0");
+    b_scf.source_control_file->feature_paragraphs.emplace_back(make_fpgh("0"));
+    auto& c_scf = op.emplace("c");
+    auto& c0 = c_scf.source_control_file->feature_paragraphs.emplace_back(make_fpgh("0"));
+    c0->dependencies.push_back(Dependency{"b"});
+
+    auto& d_scf = op.emplace("d");
+    d_scf.source_control_file->core_paragraph->dependencies.push_back(Dependency{"b", {"core"}});
+
+    auto& e_scf = op.emplace("e");
+    e_scf.source_control_file->core_paragraph->dependencies.push_back(Dependency{"b"});
+    e_scf.source_control_file->core_paragraph->depend_defaults = false;
+
+    SECTION ("toplevel depend-defaults true")
+    {
+        auto install_plan =
+            unwrap(create_versioned_install_plan(op, {Dependency{"b"}}, toplevel_spec(), DependDefaults::YES));
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_features(install_plan.install_actions[0], "b", {"0"});
+    }
+
+    SECTION ("toplevel depend-defaults false")
+    {
+        auto install_plan =
+            unwrap(create_versioned_install_plan(op, {Dependency{"b"}}, toplevel_spec(), DependDefaults::NO));
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_features(install_plan.install_actions[0], "b", {});
+
+        // a -> b[default], so depend-defaults should not suppress it
+        install_plan =
+            unwrap(create_versioned_install_plan(op, {Dependency{"a"}}, toplevel_spec(), DependDefaults::NO));
+        REQUIRE(install_plan.size() == 2);
+        check_name_and_features(install_plan.install_actions[0], "b", {"0"});
+    }
+
+    SECTION ("toplevel depend-defaults true (transitive)")
+    {
+        auto install_plan =
+            unwrap(create_versioned_install_plan(op, {Dependency{"d"}}, toplevel_spec(), DependDefaults::YES));
+        REQUIRE(install_plan.size() == 2);
+        check_name_and_features(install_plan.install_actions[0], "b", {"0"});
+    }
+
+    SECTION ("toplevel depend-defaults false (transitive)")
+    {
+        auto install_plan =
+            unwrap(create_versioned_install_plan(op, {Dependency{"d"}}, toplevel_spec(), DependDefaults::NO));
+        REQUIRE(install_plan.size() == 2);
+        check_name_and_features(install_plan.install_actions[0], "b", {});
+    }
+
+    SECTION ("transitive depend-defaults false")
+    {
+        SECTION ("toplevel false")
+        {
+            auto install_plan =
+                unwrap(create_versioned_install_plan(op, {Dependency{"e"}}, toplevel_spec(), DependDefaults::NO));
+            REQUIRE(install_plan.size() == 2);
+            check_name_and_features(install_plan.install_actions[0], "b", {});
+        }
+
+        SECTION ("toplevel core")
+        {
+            auto install_plan = unwrap(create_versioned_install_plan(
+                op, {Dependency{"e"}, Dependency{"b", {"core"}}}, toplevel_spec(), DependDefaults::YES));
+            REQUIRE(install_plan.size() == 2);
+            check_name_and_features(install_plan.install_actions[0], "b", {});
+        }
+    }
 }
 
 TEST_CASE ("version dont install default features", "[versionplan]")

src/vcpkg-test/manifests.cpp

@@ -79,6 +79,7 @@ TEST_CASE ("manifest construct minimum", "[manifests]")
 
     REQUIRE(pgh.core_paragraph->name == "zlib");
     REQUIRE(pgh.core_paragraph->raw_version == "1.2.8");
+    REQUIRE(pgh.core_paragraph->depend_defaults == true);
     REQUIRE(pgh.core_paragraph->maintainers.empty());
     REQUIRE(pgh.core_paragraph->contacts.is_empty());
     REQUIRE(pgh.core_paragraph->summary.empty());
@@ -715,6 +716,7 @@ TEST_CASE ("manifest construct maximum", "[manifests]")
         "summary": "d",
         "description": "d",
         "builtin-baseline": "123",
+        "depend-defaults": false,
         "dependencies": ["bd"],
         "default-features": ["df"],
         "features": {
@@ -729,11 +731,11 @@ TEST_CASE ("manifest construct maximum", "[manifests]")
                         "name": "order.white-lotus",
                         "features": [ "the-ancient-ways" ],
                         "platform": "!(windows & arm)"
-                },
-                {
-                    "$extra": [],
-                    "$my": [],
-                    "name": "tea"
+                    },
+                    {
+                        "$extra": [],
+                        "$my": [],
+                        "name": "tea"
                     }
                 ]
             },
@@ -767,6 +769,7 @@ TEST_CASE ("manifest construct maximum", "[manifests]")
     REQUIRE(contact_a_aa->string() == "aa");
     REQUIRE(pgh.core_paragraph->summary.size() == 1);
     REQUIRE(pgh.core_paragraph->summary[0] == "d");
+    REQUIRE(pgh.core_paragraph->depend_defaults == false);
     REQUIRE(pgh.core_paragraph->description.size() == 1);
     REQUIRE(pgh.core_paragraph->description[0] == "d");
     REQUIRE(pgh.core_paragraph->dependencies.size() == 1);

src/vcpkg-test/plan.cpp

@@ -756,6 +756,79 @@ TEST_CASE ("install with default features", "[plan]")
     features_check(install_plan.install_actions.at(1), "a", {"0", "core"});
 }
 
+TEST_CASE ("install with depend-defaults false", "[plan]")
+{
+    StatusParagraphs status_db;
+
+    PackageSpecMap spec_map;
+    auto a_spec = spec_map.emplace("a", "b");
+    auto b_spec = spec_map.emplace("b", "", {{"0", ""}}, {"0"});
+    auto c_spec = spec_map.emplace("c", "", {{"0", "b"}}, {"0"});
+    auto d_spec = spec_map.emplace("d", "b");
+    spec_map.map["d"].source_control_file->core_paragraph->depend_defaults = false;
+    spec_map.map["d"].source_control_file->core_paragraph->dependencies[0].default_features = true;
+
+    PortFileProvider::MapPortFileProvider map_port{spec_map.map};
+    MockCMakeVarProvider var_provider;
+
+    std::vector<FullPackageSpec> full_package_specs{
+        FullPackageSpec{a_spec, {"core"}},
+        FullPackageSpec{b_spec, {"core"}},
+    };
+
+    std::vector<FullPackageSpec> full_package_specs2{
+        FullPackageSpec{c_spec, {"default", "core"}},
+        FullPackageSpec{b_spec, {"core"}},
+    };
+
+    std::vector<FullPackageSpec> full_package_specs_d{
+        FullPackageSpec{d_spec, {"core"}},
+    };
+
+    // Install "a" and then "b" _should_ install default features
+    SECTION ("depend-defaults true from core")
+    {
+        auto install_plan = Dependencies::create_feature_install_plan(map_port, var_provider, full_package_specs, {});
+        REQUIRE(install_plan.size() == 2);
+        features_check(install_plan.install_actions.at(0), "b", {"0", "core"});
+        features_check(install_plan.install_actions.at(1), "a", {"core"});
+    }
+
+    SECTION ("depend-defaults true from feature")
+    {
+        auto install_plan = Dependencies::create_feature_install_plan(map_port, var_provider, full_package_specs2, {});
+        REQUIRE(install_plan.size() == 2);
+        features_check(install_plan.install_actions.at(0), "b", {"0", "core"});
+        features_check(install_plan.install_actions.at(1), "c", {"0", "core"});
+    }
+
+    SECTION ("depend-defaults false overridden from dependency")
+    {
+        auto install_plan = Dependencies::create_feature_install_plan(map_port, var_provider, full_package_specs_d, {});
+        REQUIRE(install_plan.size() == 2);
+        features_check(install_plan.install_actions.at(0), "b", {"0", "core"});
+        features_check(install_plan.install_actions.at(1), "d", {"core"});
+    }
+
+    // now, disable the implicit default dependency from `a` and `c[0]`
+    SECTION ("depend-defaults false from core")
+    {
+        spec_map.map["a"].source_control_file->core_paragraph->depend_defaults = false;
+        auto install_plan = Dependencies::create_feature_install_plan(map_port, var_provider, full_package_specs, {});
+        REQUIRE(install_plan.size() == 2);
+        features_check(install_plan.install_actions.at(0), "b", {"core"});
+        features_check(install_plan.install_actions.at(1), "a", {"core"});
+    }
+    SECTION ("depend-defaults false from feature")
+    {
+        spec_map.map["c"].source_control_file->core_paragraph->depend_defaults = false;
+        auto install_plan = Dependencies::create_feature_install_plan(map_port, var_provider, full_package_specs2, {});
+        REQUIRE(install_plan.size() == 2);
+        features_check(install_plan.install_actions.at(0), "b", {"core"});
+        features_check(install_plan.install_actions.at(1), "c", {"0", "core"});
+    }
+}
+
 TEST_CASE ("upgrade with default features 1", "[plan]")
 {
     std::vector<std::unique_ptr<StatusParagraph>> pghs;