Finish "Implement depend-defaults"

docs/vcpkg.schema.json

@@ -80,6 +80,11 @@
             }
           }
         },
+        "depend-defaults": {
+          "description": "The default value for the default-features field of a dependency",
+          "type": "boolean",
+          "default": true
+        },
         "default-features": {
           "description": "Features enabled by default with the package.",
           "type": "array",

include/vcpkg/base/contractual-constants.h

@@ -38,6 +38,7 @@ namespace vcpkg
     inline constexpr StringLiteral JsonIdDefaultTriplet = "default-triplet";
     inline constexpr StringLiteral JsonIdDemands = "demands";
     inline constexpr StringLiteral JsonIdDependencies = "dependencies";
+    inline constexpr StringLiteral JsonIdDependDefaults = "depend-defaults";
     inline constexpr StringLiteral JsonIdDescription = "description";
     inline constexpr StringLiteral JsonIdDetectedCIEnvironment = "detected-ci-environment";
     inline constexpr StringLiteral JsonIdDetector = "detector";

include/vcpkg/dependencies.h

@@ -130,13 +130,15 @@ namespace vcpkg
                                  const Path& packages_dir,
                                  UnsupportedPortAction action,
                                  UseHeadVersion use_head_version_if_user_requested,
-                                 Editable editable_if_user_requested)
+                                 Editable editable_if_user_requested,
+                                 ImplicitDefault implicit_default = ImplicitDefault::Yes)
             : randomizer(randomizer)
             , host_triplet(host_triplet)
             , packages_dir(packages_dir)
             , unsupported_port_action(action)
             , use_head_version_if_user_requested(use_head_version_if_user_requested)
             , editable_if_user_requested(editable_if_user_requested)
+            , implicit_default(implicit_default)
         {
         }
 
@@ -146,6 +148,7 @@ namespace vcpkg
         UnsupportedPortAction unsupported_port_action;
         UseHeadVersion use_head_version_if_user_requested;
         Editable editable_if_user_requested;
+        ImplicitDefault implicit_default;
     };
 
     struct CreateUpgradePlanOptions
@@ -165,6 +168,7 @@ namespace vcpkg
         Triplet host_triplet;
         Path packages_dir;
         UnsupportedPortAction unsupported_port_action;
+        ImplicitDefault implicit_default;
     };
 
     struct RemovePlan

include/vcpkg/sourceparagraph.h

@@ -113,6 +113,7 @@ namespace vcpkg
         std::string name;
         VersionScheme version_scheme = VersionScheme::String;
         Version version;
+        bool depend_defaults = true;
         std::vector<std::string> description;
         std::vector<std::string> summary;
         std::vector<std::string> maintainers;

src/vcpkg-test/dependencies.cpp

@@ -97,6 +97,7 @@ static void check_name_and_features(const InstallPlanAction& ipa,
                                     std::initializer_list<StringLiteral> features)
 {
     CHECK(ipa.spec.name() == name);
+    INFO("spec.name: " << name);
     CHECK(ipa.source_control_file_and_location.has_value());
     {
         INFO("ipa.feature_list = [" << Strings::join(", ", ipa.feature_list) << "]");
@@ -220,15 +221,20 @@ static ExpectedL<ActionPlan> create_versioned_install_plan(const IVersionedPortf
                                                            const std::vector<DependencyOverride>& overrides,
                                                            const PackageSpec& toplevel)
 {
-    return create_versioned_install_plan(
-        provider,
-        bprovider,
-        s_empty_mock_overlay,
-        var_provider,
-        deps,
-        overrides,
-        toplevel,
-        {nullptr, Test::ARM_UWP, "pkgs", UnsupportedPortAction::Error, UseHeadVersion::No, Editable::No});
+    return create_versioned_install_plan(provider,
+                                         bprovider,
+                                         s_empty_mock_overlay,
+                                         var_provider,
+                                         deps,
+                                         overrides,
+                                         toplevel,
+                                         {nullptr,
+                                          Test::ARM_UWP,
+                                          "pkgs",
+                                          UnsupportedPortAction::Error,
+                                          UseHeadVersion::No,
+                                          Editable::No,
+                                          ImplicitDefault::Yes});
 }
 
 static ExpectedL<ActionPlan> create_versioned_install_plan(const IVersionedPortfileProvider& provider,
@@ -239,15 +245,45 @@ static ExpectedL<ActionPlan> create_versioned_install_plan(const IVersionedPortf
                                                            const std::vector<DependencyOverride>& overrides,
                                                            const PackageSpec& toplevel)
 {
-    return create_versioned_install_plan(
-        provider,
-        bprovider,
-        oprovider,
-        var_provider,
-        deps,
-        overrides,
-        toplevel,
-        {nullptr, Test::ARM_UWP, "pkgs", UnsupportedPortAction::Error, UseHeadVersion::No, Editable::No});
+    return create_versioned_install_plan(provider,
+                                         bprovider,
+                                         oprovider,
+                                         var_provider,
+                                         deps,
+                                         overrides,
+                                         toplevel,
+                                         {nullptr,
+                                          Test::ARM_UWP,
+                                          "pkgs",
+                                          UnsupportedPortAction::Error,
+                                          UseHeadVersion::No,
+                                          Editable::No,
+                                          ImplicitDefault::Yes});
+}
+
+static ExpectedL<ActionPlan> create_versioned_install_plan(const IOverlayProvider& oprovider,
+                                                           const std::vector<Dependency>& deps,
+                                                           const PackageSpec& toplevel,
+                                                           ImplicitDefault implicit_default)
+{
+    MockVersionedPortfileProvider vp;
+    MockCMakeVarProvider var_provider;
+    MockBaselineProvider bp;
+
+    return vcpkg::create_versioned_install_plan(vp,
+                                                bp,
+                                                oprovider,
+                                                var_provider,
+                                                deps,
+                                                {},
+                                                toplevel,
+                                                {nullptr,
+                                                 Test::ARM_UWP,
+                                                 "pkgs",
+                                                 UnsupportedPortAction::Error,
+                                                 UseHeadVersion::No,
+                                                 Editable::No,
+                                                 implicit_default});
 }
 
 TEST_CASE ("basic version install single", "[versionplan]")
@@ -1630,11 +1666,85 @@ TEST_CASE ("version install default features", "[versionplan]")
     MockBaselineProvider bp;
     bp.v["a"] = {"1", 0};
 
-    WITH_EXPECTED(install_plan,
-                  create_versioned_install_plan(vp, bp, var_provider, {Dependency{"a"}}, {}, toplevel_spec()));
+    SECTION ("toplevel requires defaults")
+    {
+        WITH_EXPECTED(install_plan,
+                      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 =
+            create_versioned_install_plan(vp, bp, var_provider, {CoreDependency{"a"}}, {}, toplevel_spec())
+                .value_or_exit(VCPKG_LINE_INFO);
+
+        REQUIRE(install_plan.size() == 1);
+        check_name_and_version(install_plan.install_actions[0], "a", {"1", 0}, {});
+    }
+
+    SECTION ("default-features true")
+    {
+        auto install_plan = create_versioned_install_plan(vp, bp, var_provider, {Dependency{"a"}}, {}, toplevel_spec())
+                                .value_or_exit(VCPKG_LINE_INFO);
+
+        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 = create_versioned_install_plan(vp, bp, var_provider, {Dependency{"a"}}, {}, toplevel_spec())
+                                .value_or_exit(VCPKG_LINE_INFO);
+
+        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]")
+{
+    // Dependencies:
+    // b has default feature '0'
+    // a -> b[core]
+    // c -> b[default]
+
+    MockOverlayProvider op;
+    auto& a_scf = op.emplace("a");
+    a_scf.source_control_file->core_paragraph->dependencies.push_back(CoreDependency{"b"});
+    auto& b_scf = op.emplace("b");
+    b_scf.source_control_file->core_paragraph->default_features.push_back({"0"});
+    b_scf.source_control_file->feature_paragraphs.emplace_back(make_fpgh("0"));
+    auto& d_scf = op.emplace("c");
+    d_scf.source_control_file->core_paragraph->dependencies.push_back(Dependency{"b"});
+
+    SECTION ("toplevel ImplicitDefault::Yes")
+    {
+        auto install_plan = create_versioned_install_plan(op, {Dependency{"a"}}, toplevel_spec(), ImplicitDefault::Yes)
+                                .value_or_exit(VCPKG_LINE_INFO);
+        REQUIRE(install_plan.size() == 2);
+        check_name_and_features(install_plan.install_actions[0], "b", {"0"});
+        check_name_and_features(install_plan.install_actions[1], "a", {});
+    }
+
+    SECTION ("toplevel ImplicitDefault::No")
+    {
+        auto install_plan = create_versioned_install_plan(op, {Dependency{"a"}}, toplevel_spec(), ImplicitDefault::No)
+                                .value_or_exit(VCPKG_LINE_INFO);
+        REQUIRE(install_plan.size() == 2);
+
+        check_name_and_features(install_plan.install_actions[0], "b", {});
+        check_name_and_features(install_plan.install_actions[1], "a", {});
+
+        // c -> b[default], so depend-defaults should not suppress it
+        install_plan = create_versioned_install_plan(op, {Dependency{"c"}}, toplevel_spec(), ImplicitDefault::No)
+                           .value_or_exit(VCPKG_LINE_INFO);
+        REQUIRE(install_plan.size() == 2);
+        check_name_and_features(install_plan.install_actions[0], "b", {"0"});
+        check_name_and_features(install_plan.install_actions[1], "c", {});
+    }
 }
 
 TEST_CASE ("version dont install default features", "[versionplan]")

src/vcpkg-test/manifests.cpp

@@ -97,6 +97,7 @@ TEST_CASE ("manifest construct minimum", "[manifests]")
     REQUIRE(pgh.to_name() == "zlib");
     REQUIRE(pgh.to_version_scheme() == VersionScheme::String);
     REQUIRE(pgh.to_version() == Version{"1.2.8", 0});
+    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());
@@ -1060,6 +1061,68 @@ TEST_CASE ("manifest construct maximum", "[manifests]")
     check_json_eq_ordered(serialize_manifest(pgh), object);
 }
 
+TEST_CASE ("SourceParagraph manifest depend-default", "[manifests]")
+{
+    auto json = parse_json_object(R"json({
+        "name": "zlib",
+        "version-string": "1.2.8",
+        "depend-defaults": false,
+        "dependencies": [
+            "y",
+            {"name": "z", "host": true},
+            {"name": "z2", "host": true, "default-features": true}
+        ],
+        "features": {
+            "t": {
+                "description": "",
+                "dependencies": ["z"]
+            }
+        }
+    })json");
+    SECTION ("depend-defaults: false")
+    {
+        auto m_pgh = test_parse_port_manifest(json);
+        REQUIRE(m_pgh.has_value());
+        auto& pgh = **m_pgh.get();
+        REQUIRE(pgh.core_paragraph->depend_defaults == false);
+        REQUIRE(pgh.core_paragraph->dependencies.size() == 3);
+        REQUIRE(pgh.core_paragraph->dependencies[0].name == "y");
+        REQUIRE(pgh.core_paragraph->dependencies[0].default_features == false);
+        REQUIRE(pgh.core_paragraph->dependencies[1].name == "z");
+        REQUIRE(pgh.core_paragraph->dependencies[1].default_features == false);
+        REQUIRE(pgh.core_paragraph->dependencies[2].name == "z2");
+        REQUIRE(pgh.core_paragraph->dependencies[2].default_features == true);
+
+        REQUIRE(pgh.feature_paragraphs.size() == 1);
+        REQUIRE(pgh.feature_paragraphs[0]->dependencies[0].name == "z");
+        REQUIRE(pgh.feature_paragraphs[0]->dependencies[0].default_features == false);
+        check_json_eq_ordered(serialize_manifest(pgh), json);
+    }
+    SECTION ("depend-defaults: true")
+    {
+        json.remove("depend-defaults");
+        json["dependencies"].array(VCPKG_LINE_INFO)[2].object(VCPKG_LINE_INFO)["default-features"] =
+            Json::Value::boolean(false);
+        auto m_pgh = test_parse_port_manifest(json);
+        REQUIRE(m_pgh.has_value());
+        auto& pgh = **m_pgh.get();
+
+        REQUIRE(pgh.core_paragraph->depend_defaults == true);
+        REQUIRE(pgh.core_paragraph->dependencies.size() == 3);
+        REQUIRE(pgh.core_paragraph->dependencies[0].name == "y");
+        REQUIRE(pgh.core_paragraph->dependencies[0].default_features == true);
+        REQUIRE(pgh.core_paragraph->dependencies[1].name == "z");
+        REQUIRE(pgh.core_paragraph->dependencies[1].default_features == true);
+        REQUIRE(pgh.core_paragraph->dependencies[2].name == "z2");
+        REQUIRE(pgh.core_paragraph->dependencies[2].default_features == false);
+
+        REQUIRE(pgh.feature_paragraphs.size() == 1);
+        REQUIRE(pgh.feature_paragraphs[0]->dependencies[0].name == "z");
+        REQUIRE(pgh.feature_paragraphs[0]->dependencies[0].default_features == true);
+        check_json_eq_ordered(serialize_manifest(pgh), json);
+    }
+}
+
 TEST_CASE ("SourceParagraph manifest two dependencies", "[manifests]")
 {
     auto m_pgh = test_parse_port_manifest(R"json({