Support multiple --bazelrc on command line

src/main/cpp/blaze_util.cc

@@ -14,6 +14,7 @@
 
 #include "src/main/cpp/blaze_util.h"
 
+#include <algorithm>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
@@ -35,6 +36,7 @@
 namespace blaze {
 
 using std::map;
+using std::min;
 using std::string;
 using std::vector;
 
@@ -74,6 +76,40 @@ bool GetNullaryOption(const char *arg, const char *key) {
   return true;
 }
 
+std::vector<std::string> GetAllUnaryOptionValues(const vector<string>& args,
+                                                 const char *key,
+                                                 const char *ignore_after_value) {
+  vector<std::string> values;
+  for (vector<string>::size_type i = 0; i < args.size(); ++i) {
+    if (args[i] == "--") {
+      // "--" means all remaining args aren't options
+      return values;
+    }
+
+    const char* next_arg = args[std::min(i + 1, args.size() - 1)].c_str();
+    const char* result = GetUnaryOption(args[i].c_str(),
+                                        next_arg,
+                                        key);
+    if (result != nullptr) {
+      // 'key' was found and 'result' has its value.
+      values.push_back(result);
+
+      if (ignore_after_value != nullptr && strcmp(result, ignore_after_value) == 0) {
+        break;
+      }
+    }
+
+    // This is a pointer comparison, so equality means that the result must be from the next arg
+    // instead of happening to match the value from "--key=<value>" string, in which case
+    // we need to advance the index to skip the next arg for later iterations.
+    if (result == next_arg) {
+      i++;
+    }
+  }
+
+  return values;
+}
+
 const char* SearchUnaryOption(const vector<string>& args,
                               const char *key, bool warn_if_dupe) {
   if (args.empty()) {

src/main/cpp/blaze_util.h

@@ -53,6 +53,16 @@ bool GetNullaryOption(const char *arg, const char *key);
 const char* SearchUnaryOption(const std::vector<std::string>& args,
                               const char* key, bool warn_if_dupe);
 
+// Searches for 'key' in 'args' using GetUnaryOption. Arguments found after '--'
+// are omitted from the search.
+// If 'ignore_after_value' is not nullptr, all values matching the 'key' following
+// 'ignore_after_value' will be ignored.
+// Returns the values of the 'key' flag iff it occurs in args.
+// Returns empty vector otherwise.
+std::vector<std::string> GetAllUnaryOptionValues(const std::vector<std::string>& args,
+                                                 const char* key,
+                                                 const char* ignore_after_value=nullptr);
+
 // Searches for '--flag_name' and '--noflag_name' in 'args' using
 // GetNullaryOption. Arguments found after '--' are omitted from the search.
 // Returns true if '--flag_name' is a flag in args and '--noflag_name' does not

src/main/cpp/option_processor.cc

@@ -201,11 +201,22 @@ std::set<std::string> GetOldRcPaths(
         internal::FindRcAlongsideBinary(cwd, path_to_binary);
     candidate_bazelrc_paths = {workspace_rc, binary_rc, system_bazelrc_path};
   }
-  string user_bazelrc_path = internal::FindLegacyUserBazelrc(
-      SearchUnaryOption(startup_args, "--bazelrc", /* warn_if_dupe */ true),
-      workspace);
-  if (!user_bazelrc_path.empty()) {
-    candidate_bazelrc_paths.push_back(user_bazelrc_path);
+  vector<std::string> cmd_line_rc_files =
+      GetAllUnaryOptionValues(startup_args, "--bazelrc", "/dev/null");
+  // Divide the cases where the vector is empty vs not, as `FindLegacyUserBazelrc`
+  // has a case for rc_file to be a nullptr.
+  if (cmd_line_rc_files.empty()){
+    string user_bazelrc_path = internal::FindLegacyUserBazelrc(nullptr, workspace);
+    if (!user_bazelrc_path.empty()) {
+      candidate_bazelrc_paths.push_back(user_bazelrc_path);
+    }
+  } else {
+    for (auto& rc_file : cmd_line_rc_files) {
+      string user_bazelrc_path = internal::FindLegacyUserBazelrc(rc_file.c_str(), workspace);
+      if (!user_bazelrc_path.empty()) {
+        candidate_bazelrc_paths.push_back(user_bazelrc_path);
+      }
+    }
   }
   // DedupeBlazercPaths returns paths whose canonical path could be computed,
   // therefore these paths must exist.
@@ -370,20 +381,19 @@ blaze_exit_code::ExitCode OptionProcessor::GetRcFiles(
 
   // Get the command-line provided rc, passed as --bazelrc or nothing if the
   // flag is absent.
-  const char* cmd_line_rc_file =
-      SearchUnaryOption(cmd_line->startup_args, "--bazelrc",
-                        /* warn_if_dupe */ true);
-  if (cmd_line_rc_file != nullptr) {
-    string absolute_cmd_line_rc = blaze::AbsolutePathFromFlag(cmd_line_rc_file);
-    // Unlike the previous 3 paths, where we ignore it if the file does not
-    // exist or is unreadable, since this path is explicitly passed, this is an
-    // error. Check this condition here.
-    if (!blaze_util::CanReadFile(absolute_cmd_line_rc)) {
-      BAZEL_LOG(ERROR) << "Error: Unable to read .bazelrc file '"
-                       << absolute_cmd_line_rc << "'.";
-      return blaze_exit_code::BAD_ARGV;
-    }
-    rc_files.push_back(absolute_cmd_line_rc);
+  vector<std::string> cmd_line_rc_files =
+      GetAllUnaryOptionValues(cmd_line->startup_args, "--bazelrc", "/dev/null");
+  for (auto& rc_file : cmd_line_rc_files) {
+        string absolute_cmd_line_rc = blaze::AbsolutePathFromFlag(rc_file);
+        // Unlike the previous 3 paths, where we ignore it if the file does not
+        // exist or is unreadable, since this path is explicitly passed, this is an
+        // error. Check this condition here.
+        if (!blaze_util::CanReadFile(absolute_cmd_line_rc)) {
+          BAZEL_LOG(ERROR) << "Error: Unable to read .bazelrc file '"
+                           << absolute_cmd_line_rc << "'.";
+          return blaze_exit_code::BAD_ARGV;
+        }
+        rc_files.push_back(absolute_cmd_line_rc);
   }
 
   // Log which files we're looking for before removing duplicates and

src/main/java/com/google/devtools/build/lib/bazel/BazelStartupOptionsModule.java

@@ -33,10 +33,19 @@ public static final class Options extends OptionsBase {
         valueHelp = "<path>",
         help =
             "The location of the user .bazelrc file containing default values of "
-                + "Bazel options. If unspecified, Bazel uses the first .bazelrc file it finds in "
+                + "Bazel options. "
+                + "/dev/null indicates that all further `--bazelrc`s will be ignored, "
+                + "which is useful to disable the search for a user rc file, "
+                + "e.g. in release builds.\n"
+                + "This option can also be specified multiple times.\n"
+                + "E.g. with "
+                + "`--bazelrc=x.rc --bazelrc=y.rc --bazelrc=/dev/null --bazelrc=z.rc`,\n"
+                + "  1) x.rc and y.rc are read.\n"
+                + "  2) z.rc is ignored due to the prior /dev/null.\n"
+                + "If unspecified, Bazel uses the first .bazelrc file it finds in "
                 + "the following two locations: the workspace directory, then the user's home "
-                + "directory. Use /dev/null to disable the search for a user rc file, e.g. in "
-                + "release builds.")
+                + "directory.\n"
+                + "Note: command line options will always supersede any option in bazelrc.")
     public String blazerc;
 
     // TODO(b/36168162): Remove this after the transition period is ower. This now only serves to