Merge branch 'main' into rust-analyzer-discover-config

Author: krasimirgg

.bazelci/presubmit.yml

@@ -1108,7 +1108,3 @@ tasks:
       - "//..."
     test_targets:
       - "//..."
-
-buildifier:
-  version: latest
-  warnings: "all"

.github/workflows/formatting.yaml

@@ -14,6 +14,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - name: Buildifier
+        run: |
+          wget "https://github.com/bazelbuild/buildtools/releases/download/v${BUILDIFIER_VERSION}/buildifier-linux-amd64" -O buildifier
+          chmod +x ./buildifier
+          ./buildifier -lint=warn -mode=check -warnings=all -r ${{ github.workspace }}
+          rm ./buildifier
+        env:
+          BUILDIFIER_VERSION: 8.0.2
       - uses: DoozyX/clang-format-lint-action@v0.14
         with:
           source: '.'

MODULE.bazel

@@ -91,7 +91,7 @@ use_repo(
     "libc",
     "rtra",
     "rtra__serde-1.0.217",
-    "rtra__serde_json-1.0.137",
+    "rtra__serde_json-1.0.138",
     "rules_rust_test_load_arbitrary_tool",
     "rules_rust_toolchain_test_target_json",
 )

cargo/private/cargo_build_script.bzl

@@ -2,8 +2,9 @@
 
 load("@bazel_skylib//lib:paths.bzl", "paths")
 load("@bazel_skylib//rules:common_settings.bzl", "BuildSettingInfo")
-load("@bazel_tools//tools/cpp:toolchain_utils.bzl", "find_cpp_toolchain")
 load("@rules_cc//cc:action_names.bzl", "ACTION_NAMES")
+load("@rules_cc//cc:find_cc_toolchain.bzl", find_cpp_toolchain = "find_cc_toolchain")
+load("@rules_cc//cc/common:cc_common.bzl", "cc_common")
 load("//rust:defs.bzl", "rust_common")
 load("//rust:rust_common.bzl", "BuildInfo")
 
@@ -361,6 +362,7 @@ def _cargo_build_script_impl(ctx):
         env.update(ctx.configuration.default_shell_env)
 
     env.update({
+        "CARGO": "${{pwd}}/{}".format(toolchain.cargo.path),
         "CARGO_CRATE_NAME": name_to_crate_name(pkg_name),
         "CARGO_MANIFEST_DIR": manifest_dir,
         "CARGO_PKG_NAME": pkg_name,

cargo/private/internal_extensions.bzl

@@ -1,5 +1,6 @@
 """Bzlmod module extensions that are only used internally"""
 
+load("@bazel_features//:features.bzl", "bazel_features")
 load("//cargo:deps.bzl", "cargo_dependencies")
 
 def _internal_deps_impl(module_ctx):
@@ -12,10 +13,15 @@ def _internal_deps_impl(module_ctx):
     # is_dev_dep is ignored here. It's not relevant for internal_deps, as dev
     # dependencies are only relevant for module extensions that can be used
     # by other MODULES.
-    return module_ctx.extension_metadata(
-        root_module_direct_deps = [repo.repo for repo in direct_deps],
-        root_module_direct_dev_deps = [],
-    )
+    metadata_kwargs = {
+        "root_module_direct_deps": [repo.repo for repo in direct_deps],
+        "root_module_direct_dev_deps": [],
+    }
+
+    if bazel_features.external_deps.extension_metadata_has_reproducible:
+        metadata_kwargs["reproducible"] = True
+
+    return module_ctx.extension_metadata(**metadata_kwargs)
 
 # This is named a single character to reduce the size of path names when running build scripts, to reduce the chance
 # of hitting the 260 character windows path name limit.

crate_universe/extensions.bzl

@@ -373,6 +373,7 @@ load(
     "//crate_universe/private:common_utils.bzl",
     "new_cargo_bazel_fn",
 )
+load("//crate_universe/private:crates_repository.bzl", "SUPPORTED_PLATFORM_TRIPLES")
 load(
     "//crate_universe/private:crates_vendor.bzl",
     "CRATES_VENDOR_ATTRS",
@@ -1031,7 +1032,10 @@ _FROM_COMMON_ATTRS = {
             "If set, this file must exist within the workspace (but can be empty) before this rule will work."
         ),
     ),
-    "supported_platform_triples": CRATES_VENDOR_ATTRS["supported_platform_triples"],
+    "supported_platform_triples": attr.string_list(
+        doc = "A set of all platform triples to consider when generating dependencies.",
+        default = SUPPORTED_PLATFORM_TRIPLES,
+    ),
 }
 
 _from_cargo = tag_class(

crate_universe/private/crates_repository.bzl

@@ -22,7 +22,19 @@ load(
 load("//crate_universe/private:urls.bzl", "CARGO_BAZEL_SHA256S", "CARGO_BAZEL_URLS")
 load("//rust:defs.bzl", "rust_common")
 load("//rust/platform:triple.bzl", "get_host_triple")
-load("//rust/platform:triple_mappings.bzl", "SUPPORTED_PLATFORM_TRIPLES")
+
+# A reduced subset of platform triples that cover a wide range of known users.
+# The reduced set is intended to speed up the splciing step which has `O(N^2)`
+# complexity for each platform triple added.
+SUPPORTED_PLATFORM_TRIPLES = [
+    "aarch64-apple-darwin",
+    "aarch64-unknown-linux-gnu",
+    "wasm32-unknown-unknown",
+    "wasm32-wasip1",
+    "x86_64-pc-windows-msvc",
+    "x86_64-unknown-linux-gnu",
+    "x86_64-unknown-nixos-gnu",
+]
 
 def _crates_repository_impl(repository_ctx):
     # Determine the current host's platform triple

crate_universe/src/cli.rs

@@ -7,13 +7,15 @@ mod splice;
 mod vendor;
 
 use clap::Parser;
-use tracing::{Level, Subscriber};
+use tracing::Subscriber;
 use tracing_subscriber::fmt::format::{Format, Full};
 use tracing_subscriber::fmt::time::SystemTime;
 use tracing_subscriber::fmt::{FormatEvent, FormatFields};
 use tracing_subscriber::registry::LookupSpan;
 use tracing_subscriber::FmtSubscriber;
 
+pub use tracing::Level as LogLevel;
+
 pub use self::generate::GenerateOptions;
 pub use self::query::QueryOptions;
 pub use self::render::RenderOptions;
@@ -92,21 +94,17 @@ impl LoggingFormatEvent {
 }
 
 /// Initialize logging for one of the cli options.
-pub fn init_logging(name: &str, verbose: bool) {
+pub fn init_logging(name: &str, level: LogLevel) {
     if !EXPECTED_LOGGER_NAMES.contains(&name) {
         panic!(
             "Unexpected logger name {}, use of one of {:?}",
             name, EXPECTED_LOGGER_NAMES
         );
     }
 
-    // a builder for `FmtSubscriber`.
     let subscriber = FmtSubscriber::builder()
-        // all spans/events with a level higher than TRACE (e.g, debug, info, warn, etc.)
-        // will be written to stdout.
-        .with_max_level(if verbose { Level::DEBUG } else { Level::INFO })
+        .with_max_level(level)
         .event_format(LoggingFormatEvent::new(name))
-        // completes the builder.
         .finish();
 
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");

crate_universe/src/main.rs

@@ -6,27 +6,36 @@ fn main() -> cli::Result<()> {
     // Parse arguments
     let opt = cli::parse_args();
 
-    let verbose_logging = std::env::var("CARGO_BAZEL_DEBUG").is_ok();
+    let level = match std::env::var("CARGO_BAZEL_DEBUG") {
+        Ok(var) => {
+            if var == "TRACE" {
+                crate::cli::LogLevel::TRACE
+            } else {
+                crate::cli::LogLevel::DEBUG
+            }
+        }
+        Err(_) => crate::cli::LogLevel::INFO,
+    };
 
     match opt {
         cli::Options::Generate(opt) => {
-            cli::init_logging("Generate", verbose_logging);
+            cli::init_logging("Generate", level);
             cli::generate(opt)
         }
         cli::Options::Splice(opt) => {
-            cli::init_logging("Splice", verbose_logging);
+            cli::init_logging("Splice", level);
             cli::splice(opt)
         }
         cli::Options::Query(opt) => {
-            cli::init_logging("Query", verbose_logging);
+            cli::init_logging("Query", level);
             cli::query(opt)
         }
         cli::Options::Vendor(opt) => {
-            cli::init_logging("Vendor", verbose_logging);
+            cli::init_logging("Vendor", level);
             cli::vendor(opt)
         }
         cli::Options::Render(opt) => {
-            cli::init_logging("Render", verbose_logging);
+            cli::init_logging("Render", level);
             cli::render(opt)
         }
     }

crate_universe/src/metadata/cargo_tree_resolver.rs

@@ -9,7 +9,7 @@ use anyhow::{anyhow, bail, Context, Result};
 use camino::Utf8Path;
 use semver::Version;
 use serde::{Deserialize, Serialize};
-use tracing::debug;
+use tracing::{debug, trace};
 use url::Url;
 
 use crate::config::CrateId;
@@ -137,6 +137,12 @@ impl TreeResolver {
             // number of processes (which can be +400 and hit operating system limitations).
             let mut target_triple_to_child = BTreeMap::<String, Child>::new();
 
+            debug!(
+                "Spawning `cargo tree` processes for host `{}`: {}",
+                host_triple,
+                cargo_target_triples.keys().len(),
+            );
+
             for target_triple in cargo_target_triples.keys() {
                 // We use `cargo tree` here because `cargo metadata` doesn't report
                 // back target-specific features (enabled with `resolver = "2"`).
@@ -178,12 +184,6 @@ impl TreeResolver {
                 target_triple_to_child.insert(target_triple.clone(), child);
             }
 
-            debug!(
-                "Spawned `cargo tree` processes for host `{}`: {}",
-                host_triple,
-                target_triple_to_child.len(),
-            );
-
             for (target_triple, child) in target_triple_to_child.into_iter() {
                 let output = child.wait_with_output().with_context(|| {
                     format!(
@@ -194,11 +194,13 @@ impl TreeResolver {
                     )
                 })?;
                 if !output.status.success() {
-                    eprintln!("{}", String::from_utf8_lossy(&output.stdout));
-                    eprintln!("{}", String::from_utf8_lossy(&output.stderr));
+                    tracing::error!("{}", String::from_utf8_lossy(&output.stdout));
+                    tracing::error!("{}", String::from_utf8_lossy(&output.stderr));
                     bail!(format!("Failed to run cargo tree: {}", output.status))
                 }
 
+                tracing::trace!("`cargo tree --target={}` completed.", target_triple);
+
                 // Replicate outputs for any de-duplicated platforms
                 for host_plat in cargo_host_triples[host_triple].iter() {
                     for target_plat in cargo_target_triples[&target_triple].iter() {
@@ -348,7 +350,7 @@ impl TreeResolver {
 
         for (host_triple, target_streams) in deps_tree_streams.into_iter() {
             for (target_triple, stdout) in target_streams.into_iter() {
-                debug!(
+                trace!(
                     "Parsing (host={}) `cargo tree --target {}` output:\n```\n{}\n```",
                     host_triple,
                     target_triple,