Add declared crate features to the Rust sync tool (#573)

## Usage and product changes
Introduce `declared_features` to the Rust sync tool, parsed from the
tags of Bazel `rust_` targets, to generate `Cargo.toml` files with
predeclared features that are not automatically used in the dependent
targets (this happens with `crate_features`).

## Motivation
We need a way to declare features without their automatic usage to be
able to activate them manually through `cargo` only when needed.

## Implementation
Parse `tags` in order to search for a new tag containing a list of
declared features. Save these features into a new separate field which
is then passed to the crate features declaration.

Author: farost

builder/rust/cargo/project_aspect.bzl

@@ -19,15 +19,16 @@ _BIN_ENTRY_POINT = "main.rs"
 _LIB_ENTRY_POINT = "lib.rs"
 
 CrateInfo = provider(fields = [
-    "kind",            # str
-    "crate_name",      # str
-    "workspace_name",  # str
-    "crate_path",      # str
-    "version",         # str
-    "features",        # List[str]
-    "deps",            # List[target]
-    "transitive_deps", # List[target]
-    "build_deps",      # List[target]
+    "kind",              # str
+    "crate_name",        # str
+    "workspace_name",    # str
+    "crate_path",        # str
+    "version",           # str
+    "enabled_features",  # List[str]
+    "features",          # List[str]
+    "deps",              # List[target]
+    "transitive_deps",   # List[target]
+    "build_deps",        # List[target]
 ])
 
 CargoProjectInfo = provider(fields = [
@@ -102,13 +103,17 @@ rust_cargo_properties_aspect = aspect(
 )
 
 def _crate_info(ctx, target):
+    features = []
     if _is_universe_crate(target):
         crate_name = str(target.label).split(".")[0].rsplit("-", 1)[0].removeprefix("@crates__")
     else:
         crate_name = ctx.rule.attr.name
         for tag in ctx.rule.attr.tags:
             if tag.startswith("crate-name"):
                 crate_name = tag.split("=")[1]
+            elif tag.startswith("declared-features"):
+                feature_str = tag.split("=")[1]
+                features = [f.strip() for f in feature_str.split(",") if f.strip()]
 
     workspace_name = target.label.workspace_name
     crate_path = target.label.package
@@ -121,7 +126,8 @@ def _crate_info(ctx, target):
         workspace_name = workspace_name,
         crate_path = crate_path,
         version = getattr(ctx.rule.attr, "version", "0.0.0"),
-        features = getattr(ctx.rule.attr, "crate_features", []),
+        enabled_features = getattr(ctx.rule.attr, "crate_features", []),
+        features = features,
         deps = deps,
         transitive_deps = transitive_deps,
         build_deps = _crate_build_deps(ctx, target),
@@ -227,6 +233,7 @@ def _get_properties(target, ctx, source_files, crate_info):
     properties = {}
     properties["name"] = crate_info.crate_name
     properties["path"] = crate_info.crate_path
+    properties["enabled.features"] = ",".join(crate_info.enabled_features)
     properties["features"] = ",".join(crate_info.features)
     properties["target.name"] = target.label.name
     properties["type"] = target_type
@@ -259,8 +266,8 @@ def _crate_deps_info(target, crate_info):
             repository_relative_path = target_to_root + "/" + root_to_dep
             location = "path=../{};localpath={}".format(dependency_info.crate_name, repository_relative_path)
 
-        features = ",".join(dependency_info.features)
-        info = location + (";features={}".format(features) if features else "")
+        enabled_features = ",".join(dependency_info.enabled_features)
+        info = location + (";enabled.features={}".format(enabled_features) if enabled_features else "")
         deps_info[dependency_info.crate_name] = info
     return deps_info
 

tool/ide/RustManifestSyncer.kt

@@ -34,6 +34,7 @@ import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.Paths
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.BUILD_DEPS
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.DEPS_PREFIX
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.EDITION
+import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.ENABLED_FEATURES
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.ENTRY_POINT_PATH
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.FEATURES
 import com.typedb.dependencies.tool.ide.RustManifestSyncer.WorkspaceSyncer.TargetProperties.Keys.LOCAL_PATH
@@ -263,7 +264,9 @@ class RustManifestSyncer : Callable<Unit> {
 
                 cargoToml.createSubConfig().apply {
                     cargoToml.set<Config>("features", this)
-                    properties.features.forEach { set<Config>(it, emptyList<String>()) }
+                    (properties.enabledFeatures + properties.features)
+                        .distinct()
+                        .forEach { set<Config>(it, emptyList<String>()) }
                 }
 
                 cargoToml.createEntryPointSubConfig()
@@ -404,6 +407,7 @@ class RustManifestSyncer : Callable<Unit> {
                 val targetName: String,
                 val cratePath: String,
                 val type: Type,
+                val enabledFeatures: Collection<String>,
                 val features: Collection<String>,
                 val version: String,
                 val edition: String?,
@@ -483,7 +487,7 @@ class RustManifestSyncer : Callable<Unit> {
                         val name = rawKey.split(".", limit = 2)[1]
                         val rawValueProps = rawValue.split(";")
                                 .associate { it.split("=", limit = 2).let { parts -> parts[0] to parts[1] } }
-                        val features = rawValueProps[FEATURES]?.split(",")?.filter { it != "bazel" } ?: emptyList();
+                        val features = rawValueProps[ENABLED_FEATURES]?.split(",")?.filter { it != "bazel" } ?: emptyList();
                         return if (VERSION in rawValueProps) {
                             Crate(
                                     name = name,
@@ -542,6 +546,7 @@ class RustManifestSyncer : Callable<Unit> {
                                 name = props.getProperty(NAME),
                                 targetName = props.getProperty(TARGET_NAME),
                                 type = Type.of(props.getProperty(TYPE)),
+                                enabledFeatures = props.getProperty(ENABLED_FEATURES).split(",").filter { it.isNotBlank() },
                                 features = props.getProperty(FEATURES).split(",").filter { it.isNotBlank() },
                                 version = props.getProperty(VERSION),
                                 edition = props.getProperty(EDITION, "2021"),
@@ -567,6 +572,7 @@ class RustManifestSyncer : Callable<Unit> {
                                 name = base.name,
                                 targetName = base.targetName,
                                 type = base.type,
+                                enabledFeatures = (base.enabledFeatures + properties.enabledFeatures).distinct(),
                                 features = (base.features + properties.features).distinct(),
                                 version = base.version,
                                 edition = base.edition,
@@ -595,6 +601,7 @@ class RustManifestSyncer : Callable<Unit> {
                                 name = first.cratePath.replace('/', '-'),
                                 targetName = first.targetName,
                                 type = first.type,
+                                enabledFeatures = first.enabledFeatures,
                                 features = first.features,
                                 version = first.version,
                                 edition = first.edition,
@@ -617,6 +624,7 @@ class RustManifestSyncer : Callable<Unit> {
                                 name = lib.name,
                                 targetName = lib.targetName,
                                 type = lib.type,
+                                enabledFeatures = lib.enabledFeatures,
                                 features = lib.features,
                                 version = lib.version,
                                 edition = lib.edition,
@@ -649,6 +657,7 @@ class RustManifestSyncer : Callable<Unit> {
                 const val DEPS_PREFIX = "deps"
                 const val EDITION = "edition"
                 const val ENTRY_POINT_PATH = "entry.point.path"
+                const val ENABLED_FEATURES = "enabled.features"
                 const val FEATURES = "features"
                 const val TARGET_NAME = "target.name"
                 const val NAME = "name"