Use flags-as-proto to determine command line schema

.gitattributes

@@ -0,0 +1,3 @@
+* text=auto
+
+*.b64 binary

cli/parser/BUILD

@@ -10,9 +10,11 @@ go_library(
         "//cli/log",
         "//cli/storage",
         "//cli/workspace",
+        "//proto:bazel_flags_go_proto",
         "//proto:remote_execution_go_proto",
         "//server/remote_cache/digest",
         "//server/util/disk",
+        "//server/util/proto",
         "@com_github_google_shlex//:shlex",
     ],
 )

cli/parser/parser.go

@@ -5,6 +5,7 @@ package parser
 import (
 	"bufio"
 	"bytes"
+	"encoding/base64"
 	"fmt"
 	"io"
 	"os"
@@ -21,8 +22,10 @@ import (
 	"github.com/buildbuddy-io/buildbuddy/cli/workspace"
 	"github.com/buildbuddy-io/buildbuddy/server/remote_cache/digest"
 	"github.com/buildbuddy-io/buildbuddy/server/util/disk"
+	"github.com/buildbuddy-io/buildbuddy/server/util/proto"
 	"github.com/google/shlex"
 
+	bfpb "github.com/buildbuddy-io/buildbuddy/proto/bazel_flags"
 	repb "github.com/buildbuddy-io/buildbuddy/proto/remote_execution"
 )
 
@@ -350,15 +353,72 @@ func (s *CommandLineSchema) CommandSupportsOpt(opt string) bool {
 	return false
 }
 
+func GetOptionSetsfromProto(args []string, flagCollection *bfpb.FlagCollection, onlyStartupOptions bool) (map[string]*OptionSet, error) {
+	sets := make(map[string]*OptionSet)
+	for _, info := range flagCollection.FlagInfos {
+		if info.GetName() == "bazelrc" {
+			// `bazel help flags-as-proto` incorrectly reports `bazelrc` as not
+			// allowing multiple values.
+			// See https://github.com/bazelbuild/bazel/issues/24730 for more info.
+			*info.AllowsMultiple = true
+		}
+		o := &Option{
+			Name:      info.GetName(),
+			ShortName: info.GetAbbreviation(),
+			Multi:     info.GetAllowsMultiple(),
+			BoolLike:  info.GetHasNegativeFlag(),
+		}
+		for _, cmd := range info.GetCommands() {
+			var set *OptionSet
+			var ok bool
+			if set, ok = sets[cmd]; !ok {
+				set = &OptionSet{
+					All:         []*Option{},
+					ByName:      make(map[string]*Option),
+					ByShortName: make(map[string]*Option),
+				}
+				sets[cmd] = set
+			}
+			set.All = append(set.All, o)
+			set.ByName[o.Name] = o
+			if o.ShortName != "" {
+				set.ByShortName[o.ShortName] = o
+			}
+		}
+	}
+	return sets, nil
+}
+
 // GetCommandLineSchema returns the effective CommandLineSchemas for the given
 // command line.
 func getCommandLineSchema(args []string, bazelHelp BazelHelpFunc, onlyStartupOptions bool) (*CommandLineSchema, error) {
-	startupHelp, err := bazelHelp("startup_options")
-	if err != nil {
-		return nil, err
+	var optionSets map[string]*OptionSet
+	// try flags-as-proto first; fall back to parsing help if bazel version does not support it.
+	if protoHelp, err := bazelHelp("flags-as-proto"); err == nil {
+		protoHelp = strings.TrimSpace(protoHelp)
+		b, err := base64.StdEncoding.DecodeString(protoHelp)
+		if err != nil {
+			return nil, err
+		}
+		flagCollection := &bfpb.FlagCollection{}
+		if err := proto.Unmarshal(b, flagCollection); err != nil {
+			return nil, err
+		}
+		sets, err := GetOptionSetsfromProto(args, flagCollection, onlyStartupOptions)
+		if err != nil {
+			return nil, err
+		}
+		optionSets = sets
 	}
-	schema := &CommandLineSchema{
-		StartupOptions: parseBazelHelp(startupHelp, "startup_options"),
+	schema := &CommandLineSchema{}
+	if startupOptions, ok := optionSets["startup"]; ok {
+		schema.StartupOptions = startupOptions
+	} else {
+		startupHelp, err := bazelHelp("startup_options")
+		if err != nil {
+			return nil, err
+		}
+		schema.StartupOptions = parseBazelHelp(startupHelp, "startup_options")
 	}
 	bazelCommands, err := BazelCommands()
 	if err != nil {
@@ -394,11 +454,15 @@ func getCommandLineSchema(args []string, bazelHelp BazelHelpFunc, onlyStartupOpt
 	if schema.Command == "" {
 		return schema, nil
 	}
-	commandHelp, err := bazelHelp(schema.Command)
-	if err != nil {
-		return nil, err
+	if commandOptions, ok := optionSets[schema.Command]; ok {
+		schema.CommandOptions = commandOptions
+	} else {
+		commandHelp, err := bazelHelp(schema.Command)
+		if err != nil {
+			return nil, err
+		}
+		schema.CommandOptions = parseBazelHelp(commandHelp, schema.Command)
 	}
-	schema.CommandOptions = parseBazelHelp(commandHelp, schema.Command)
 	return schema, nil
 }