Add support for %bazel.version*% variables in bazelrc imports

willstranton · willstranton · commit bc48f4c0d5ab · 2025-10-30T02:52:43.000Z
Follows the proposal: #24043 (comment) by mattyclarkson@ to add support for the following variables when importing additional bazelrc files. Variables are followed by their values for the hypothetical build label 9.4.2-pre.20251022.1: - %bazel.version% - 9.4.2-pre.20251022.1 - %bazel.version.major% - 9 - %bazel.version.minor% - 4 - %bazel.version.patch% - 2 - %bazel.version.prerelease% - pre.20251022.1 - %bazel.version.buildmetadata% - (empty) - %bazel.version.major.minor% - 9.4 - %bazel.version.major.minor.patch% - 9.4.2 Eg. If your bazel version was 8.4.2-pre.20251022.1 and your .bazelrc had the following: > try-import %bazel.version%.bazelrc > import %bazel.version.major%.%bazel.version.minor%-%bazel.version.patch%.bazelrc > try-import %bazel.version.major%.bazelrc It would be evaluated to: > try-import 8.4.2.bazelrc > import 8.4-2.bazelrc > try-import 8.bazelrc # Implementation details: ## Build label extraction: Before: The build label was extracted out only when calling `bazel --version` and when running in client server mode. After: Now we always extract the the build label out early in the start of main ## Piping of build label: The build label is stored in the OptionProcessor so that it can be passed to `RcFile` when parsing occurs. ## Parsing and mapping of variables: The build label is parsed during `RcFile::ParseFile` into its constituent parts (major, minor, patch). This occurs EACH TIME an import statement is found in a .rc file. This is wasteful, but the logic is simple enough that it shouldn't matter. Interpolation of the build label happens first, followed by `%workspace%`. Fixes: #24043
diff --git a/src/main/cpp/blaze.cc b/src/main/cpp/blaze.cc
@@ -1481,9 +1481,7 @@ void PrintBazelLeaf() {
   printf("%s\n", leaf.c_str());
 }
 
-void PrintVersionInfo(const string &self_path, const string &product_name) {
-  string build_label;
-  ExtractBuildLabel(self_path, &build_label);
+void PrintVersionInfo(const string &build_label, const string &product_name) {
   printf("%s %s\n", product_name.c_str(), build_label.c_str());
 }
 
@@ -1495,7 +1493,8 @@ static void RunLauncher(const string &self_path,
                         const WorkspaceLayout &workspace_layout,
                         const string &workspace, LoggingInfo *logging_info,
                         StartupInterceptor *interceptor,
-                        CommandExtensionAdder *command_extension_adder) {
+                        CommandExtensionAdder *command_extension_adder,
+                        const string &build_label) {
   blaze_server = new BlazeServer(startup_options, command_extension_adder);
 
   const std::optional<DurationMillis> command_wait_duration =
@@ -1566,8 +1565,6 @@ static void RunLauncher(const string &self_path,
                  option_processor, startup_options, logging_info,
                  extract_data_duration, command_wait_duration, blaze_server);
   } else {
-    string build_label;
-    ExtractBuildLabel(self_path, &build_label);
     RunClientServerMode(
         server_exe, server_exe_args, server_dir, workspace_layout, workspace,
         option_processor, startup_options, logging_info, extract_data_duration,
@@ -1593,8 +1590,15 @@ int Main(int argc, const char *const *argv, WorkspaceLayout *workspace_layout,
     return blaze_exit_code::SUCCESS;
   }
 
+  // Extract build_label to be used in two places:
+  // 1) PrintVersionInfo()
+  // 2) Resolving %bazel.version*% variables in .bazelrc files.
+  string build_label;
+  ExtractBuildLabel(self_path, &build_label);
+  option_processor->SetBuildLabel(build_label);
+
   if (argc == 2 && strcmp(argv[1], "--version") == 0) {
-    PrintVersionInfo(self_path, option_processor->GetLowercaseProductName());
+    PrintVersionInfo(build_label, option_processor->GetLowercaseProductName());
     return blaze_exit_code::SUCCESS;
   }
 
@@ -1671,7 +1675,7 @@ int Main(int argc, const char *const *argv, WorkspaceLayout *workspace_layout,
 
   RunLauncher(self_path, archive_contents, install_md5, *startup_options,
               *option_processor, *workspace_layout, workspace, &logging_info,
-              interceptor, command_extension_adder);
+              interceptor, command_extension_adder, build_label);
   return 0;
 }
 
diff --git a/src/main/cpp/blaze.h b/src/main/cpp/blaze.h
@@ -26,7 +26,7 @@ namespace blaze {
 
 // Prints client version information to standard output, e.g. when invoking the
 // client with "--version".
-void PrintVersionInfo(const std::string& self_path,
+void PrintVersionInfo(const std::string& build_label,
                       const std::string& product_name);
 
 int Main(int argc, const char* const* argv, WorkspaceLayout* workspace_layout,
diff --git a/src/main/cpp/option_processor.cc b/src/main/cpp/option_processor.cc
@@ -447,7 +447,8 @@ blaze_exit_code::ExitCode OptionProcessor::GetRcFiles(
   for (const std::string& top_level_bazelrc_path : rc_files) {
     std::unique_ptr<RcFile> parsed_rc;
     blaze_exit_code::ExitCode parse_rcfile_exit_code = ParseRcFile(
-        workspace_layout, workspace, top_level_bazelrc_path, &parsed_rc, error);
+        workspace_layout, workspace, top_level_bazelrc_path, build_label_,
+        &parsed_rc, error);
     if (parse_rcfile_exit_code != blaze_exit_code::SUCCESS) {
       return parse_rcfile_exit_code;
     }
@@ -488,14 +489,16 @@ blaze_exit_code::ExitCode OptionProcessor::GetRcFiles(
 blaze_exit_code::ExitCode ParseRcFile(const WorkspaceLayout* workspace_layout,
                                       const std::string& workspace,
                                       const std::string& rc_file_path,
+                                      const std::string& build_label,
                                       std::unique_ptr<RcFile>* result_rc_file,
                                       std::string* error) {
   assert(!rc_file_path.empty());
   assert(result_rc_file != nullptr);
 
   RcFile::ParseError parse_error;
   std::unique_ptr<RcFile> parsed_file = RcFile::Parse(
-      rc_file_path, workspace_layout, workspace, &parse_error, error);
+      rc_file_path, workspace_layout, workspace, &parse_error, error,
+      build_label);
   if (parsed_file == nullptr) {
     return internal::ParseErrorToExitCode(parse_error);
   }
diff --git a/src/main/cpp/option_processor.h b/src/main/cpp/option_processor.h
@@ -127,6 +127,11 @@ class OptionProcessor {
   // the failure. Otherwise, the server will handle any required logging.
   void PrintStartupOptionsProvenanceMessage() const;
 
+  // Sets the build label.
+  void SetBuildLabel(const std::string &build_label) {
+    build_label_ = build_label;
+  }
+
   // Parse the files in `blazercs` and return all options that need to be passed
   // to the server. The options are returned in the order they should be appear
   // on the command line (later options have precedence over earlier ones).
@@ -180,12 +185,16 @@ class OptionProcessor {
   // Path to the system-wide bazelrc configuration file.
   // This is configurable for testing purposes only.
   const std::string system_bazelrc_path_;
+
+  // Build label for Bazel.
+  std::string build_label_;
 };
 
 // Parses and returns the contents of the rc file.
 blaze_exit_code::ExitCode ParseRcFile(const WorkspaceLayout* workspace_layout,
                                       const std::string& workspace,
                                       const std::string& rc_file_path,
+                                      const std::string& build_label,
                                       std::unique_ptr<RcFile>* result_rc_file,
                                       std::string* error);
 
diff --git a/src/main/cpp/rc_file.cc b/src/main/cpp/rc_file.cc
@@ -16,6 +16,7 @@
 
 #include <memory>
 #include <optional>
+#include <regex>
 #include <string>
 #include <utility>
 #include <vector>
@@ -31,6 +32,7 @@
 #include "absl/strings/match.h"
 #include "absl/strings/str_cat.h"
 #include "absl/strings/str_format.h"
+#include "absl/strings/str_replace.h"
 #include "absl/strings/str_split.h"
 #include "absl/strings/string_view.h"
 #include "absl/types/span.h"
@@ -43,18 +45,20 @@ static constexpr absl::string_view kCommandTryImport = "try-import";
 /*static*/ std::unique_ptr<RcFile> RcFile::Parse(
     const std::string& filename, const WorkspaceLayout* workspace_layout,
     const std::string& workspace, ParseError* error, std::string* error_text,
-    ReadFileFn read_file, CanonicalizePathFn canonicalize_path) {
+    const std::string& build_label, ReadFileFn read_file,
+    CanonicalizePathFn canonicalize_path) {
   auto rcfile = absl::WrapUnique(new RcFile());
   std::vector<std::string> initial_import_stack = {filename};
-  *error = rcfile->ParseFile(filename, workspace, *workspace_layout, read_file,
-                             canonicalize_path, initial_import_stack,
-                             error_text);
+  *error = rcfile->ParseFile(filename, workspace, *workspace_layout,
+                             build_label, read_file, canonicalize_path,
+                             initial_import_stack, error_text);
   return (*error == ParseError::NONE) ? std::move(rcfile) : nullptr;
 }
 
 RcFile::ParseError RcFile::ParseFile(const std::string& filename,
                                      const std::string& workspace,
                                      const WorkspaceLayout& workspace_layout,
+                                     const std::string& build_label,
                                      ReadFileFn read_file,
                                      CanonicalizePathFn canonicalize_path,
                                      std::vector<std::string>& import_stack,
@@ -109,17 +113,24 @@ RcFile::ParseError RcFile::ParseFile(const std::string& filename,
       return ParseError::INVALID_FORMAT;
     }
 
-    std::string& import_filename = words[1];
+    std::string import_filename = ReplaceBuildVars(build_label, words[1]);
     if (absl::StartsWith(import_filename, WorkspaceLayout::kWorkspacePrefix)) {
       const auto resolved_filename =
           workspace_layout.ResolveWorkspaceRelativeRcFilePath(workspace,
                                                               import_filename);
       if (!resolved_filename.has_value()) {
         if (command == kCommandImport) {
+          // If build variables were replaced in the filename, print out the
+          // evaluated path so they know the file lookup that was attempted.
+          std::string evaluated_line = ReplaceBuildVars(build_label, line);
+          std::string evaluated_warning;
+          if (line != evaluated_line) {
+            evaluated_warning = absl::StrFormat("file evaluated to '%s' - ", evaluated_line);
+          }
           *error_text = absl::StrFormat(
               "Nonexistent path in import declaration in config file '%s': '%s'"
-              " (are you in your source checkout/WORKSPACE?)",
-              canonical_filename, line);
+              " (%sare you in your source checkout/WORKSPACE?)",
+              canonical_filename, line, evaluated_warning);
           return ParseError::INVALID_FORMAT;
         }
         // For try-import, we ignore it if we couldn't find a file.
@@ -144,8 +155,8 @@ RcFile::ParseError RcFile::ParseFile(const std::string& filename,
 
     import_stack.push_back(import_filename);
     if (ParseError parse_error =
-            ParseFile(import_filename, workspace, workspace_layout, read_file,
-                      canonicalize_path, import_stack, error_text);
+            ParseFile(import_filename, workspace, workspace_layout, build_label,
+                      read_file, canonicalize_path, import_stack, error_text);
         parse_error != ParseError::NONE) {
       if (parse_error == ParseError::UNREADABLE_FILE &&
           command == kCommandTryImport) {
@@ -175,5 +186,60 @@ bool RcFile::ReadFileDefault(const std::string& filename, std::string* contents,
 std::string RcFile::CanonicalizePathDefault(const std::string& filename) {
   return blaze_util::MakeCanonical(filename.c_str());
 }
+namespace {
+// When the build label can't be parsed into a proper semantic version (per
+// semver.org), this will be the value for each of the variables below.
+constexpr char kNoVersion[] = "no_version";
+// Variables that can be interpolated in .bazelrc when importing files.
+constexpr char kBazelVersion[] =
+    "%bazel.version%"; // The full build label Eg. 8.4.2 or 9.0.0-pre.20251022.1
+constexpr char kBazelVersionMajor[] =
+    "%bazel.version.major%"; // Eg. "8" in 8.4.2
+constexpr char kBazelVersionMinor[] =
+    "%bazel.version.minor%"; // Eg. "4" in 8.4.2
+constexpr char kBazelVersionPatch[] =
+    "%bazel.version.patch%"; // Eg. "2" in 8.4.2
+constexpr char kBazelVersionPrerelease[] =
+    "%bazel.version.prerelease%"; // Eg. "pre.20251022" in 9.0.0-pre.20251022
+constexpr char kBazelVersionBuildMetadata[] =
+    "%bazel.version.buildmetadata%"; // Eg. "c0075e8a6b" in 9.0.0+c0075e8a6b
+constexpr char kBazelVersionMajorMinor[] =
+    "%bazel.version.major.minor%"; // Eg. "8.4" in 8.4.2
+constexpr char kBazelVersionMajorMinorPatch[] =
+    "%bazel.version.major.minor.patch%"; // Eg. "9.0.0" in 9.0.0-pre.20251022.1
+
+// Semantic version regex copied verbatim from
+// https://semver.org/#is-there-a-suggested-regular-expression-regex-to-check-a-semver-string
+const std::regex kSemverRe(
+    R"(^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$)");
+}  // namespace
+
+std::string ReplaceBuildVars(const std::string& build_label,
+                             absl::string_view import_filename) {
+  std::string version = kNoVersion;
+  std::string major = kNoVersion;
+  std::string minor = kNoVersion;
+  std::string patch = kNoVersion;
+  std::string prerelease = kNoVersion;
+  std::string buildmetadata = kNoVersion;
+  if (std::smatch m; std::regex_match (build_label, m, kSemverRe)) {
+    version = m[0];
+    major = m[1];
+    minor = m[2];
+    patch = m[3];
+    prerelease = m[4];
+    buildmetadata = m[5];
+  }
+  return absl::StrReplaceAll(
+      import_filename,
+      {{kBazelVersion, version},
+       {kBazelVersionMajor, major},
+       {kBazelVersionMinor, minor},
+       {kBazelVersionPatch, patch},
+       {kBazelVersionPrerelease, prerelease},
+       {kBazelVersionBuildMetadata, buildmetadata},
+       {kBazelVersionMajorMinor, absl::StrCat(major, ".", minor)},
+       {kBazelVersionMajorMinorPatch, absl::StrCat(major, ".", minor, "." + patch)}});
+}
 
 }  // namespace blaze
diff --git a/src/main/cpp/rc_file.h b/src/main/cpp/rc_file.h
@@ -15,6 +15,7 @@
 #define BAZEL_SRC_MAIN_CPP_RC_FILE_H_
 
 #include <memory>
+#include <regex>
 #include <string>
 #include <vector>
 
@@ -44,7 +45,7 @@ class RcFile {
   static std::unique_ptr<RcFile> Parse(
       const std::string& filename, const WorkspaceLayout* workspace_layout,
       const std::string& workspace, ParseError* error, std::string* error_text,
-      ReadFileFn read_file = &ReadFileDefault,
+      const std::string &build_label, ReadFileFn read_file = &ReadFileDefault,
       CanonicalizePathFn canonicalize_path = &CanonicalizePathDefault);
 
   // Movable and copyable.
@@ -69,6 +70,7 @@ class RcFile {
   ParseError ParseFile(const std::string& filename,
                        const std::string& workspace,
                        const WorkspaceLayout& workspace_layout,
+                       const std::string& build_label,
                        ReadFileFn read_file,
                        CanonicalizePathFn canonicalize_path,
                        std::vector<std::string>& import_stack,
@@ -86,6 +88,8 @@ class RcFile {
   OptionMap options_;
 };
 
+std::string ReplaceBuildVars(const std::string& build_label,
+                                      absl::string_view import_filename);
 }  // namespace blaze
 
 #endif  // BAZEL_SRC_MAIN_CPP_RC_FILE_H_
diff --git a/src/test/cpp/rc_file_test.cc b/src/test/cpp/rc_file_test.cc
diff --git a/src/test/cpp/rc_options_test.cc b/src/test/cpp/rc_options_test.cc
