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

willstranton · willstranton · commit c0075e8a6bc1 · 2025-10-29T03:33:03.000Z
Follows the proposal: #24043 (comment) by mattyclarkson@ to add support for the following variables when importing additional bazelrc files: - %bazel.version% - %bazel.version.major% - %bazel.version.minor% - %bazel.version.patch% Eg. If your bazel version was 8.4.2 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
@@ -31,6 +31,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 +44,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 +112,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 +154,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) {
@@ -176,4 +186,29 @@ std::string RcFile::CanonicalizePathDefault(const std::string& filename) {
   return blaze_util::MakeCanonical(filename.c_str());
 }
 
+std::string ReplaceBuildVars(absl::string_view build_label,
+                             absl::string_view import_filename) {
+  absl::string_view version;
+  absl::string_view major;
+  absl::string_view minor;
+  absl::string_view patch;
+  std::vector<absl::string_view> v =
+      absl::StrSplit(build_label, absl::MaxSplits('.', 2));
+  if (v.size() == 3) {
+    version = build_label;
+    major = v.at(0);
+    minor = v.at(1);
+    patch = v.at(2);
+  } else {
+    version = kNoVersion;
+    major = kNoVersion;
+    minor = kNoVersion;
+    patch = kNoVersion;
+  }
+  return absl::StrReplaceAll(import_filename, {{kBazelVersion, version},
+                                               {kBazelVersionMajor, major},
+                                               {kBazelVersionMinor, minor},
+                                               {kBazelVersionPatch, patch}});
+}
+
 }  // namespace blaze
diff --git a/src/main/cpp/rc_file.h b/src/main/cpp/rc_file.h
@@ -44,7 +44,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 +69,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 +87,18 @@ class RcFile {
   OptionMap options_;
 };
 
+// When the build label can't be parsed into a naive semantic version (three
+// strings separated by dots), this will be the value for the version name,
+// major, minor and patch.
+static constexpr char kNoVersion[] = "no_version";
+// Variables that can be interpolated in .bazelrc when importing files.
+static constexpr char kBazelVersion[] = "%bazel.version%";
+static constexpr char kBazelVersionMajor[] = "%bazel.version.major%";
+static constexpr char kBazelVersionMinor[] = "%bazel.version.minor%";
+static constexpr char kBazelVersionPatch[] = "%bazel.version.patch%";
+std::string ReplaceBuildVars(absl::string_view 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
