go: use "shell" params file format instead of "multiline" (bazel-contrib#2655)

This lets arguments contain newlines.

Fixes bazel-contrib#2635

Author: Jay Conrod

go/private/context.bzl

@@ -128,7 +128,7 @@ def _new_args(go):
 def _builder_args(go, command = None):
     args = go.actions.args()
     args.use_param_file("-param=%s")
-    args.set_param_file_format("multiline")
+    args.set_param_file_format("shell")
     if command:
         args.add(command)
     args.add("-sdk", go.sdk.root_file.dirname)
@@ -139,7 +139,7 @@ def _builder_args(go, command = None):
 def _tool_args(go):
     args = go.actions.args()
     args.use_param_file("-param=%s")
-    args.set_param_file_format("multiline")
+    args.set_param_file_format("shell")
     return args
 
 def _new_library(go, name = None, importpath = None, resolver = None, importable = True, testfilter = None, is_main = False, **kwargs):

go/tools/builders/asm.go

@@ -30,7 +30,7 @@ import (
 // Go rules as an action.
 func asm(args []string) error {
 	// Parse arguments.
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}

go/tools/builders/builder.go

@@ -28,7 +28,7 @@ func main() {
 	log.SetFlags(0)
 	log.SetPrefix("builder: ")
 
-	args, err := readParamsFiles(os.Args[1:])
+	args, err := expandParamsFiles(os.Args[1:])
 	if err != nil {
 		log.Fatal(err)
 	}

go/tools/builders/compile.go

@@ -29,7 +29,7 @@ import (
 
 func compile(args []string) error {
 	// Parse arguments.
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}

go/tools/builders/compilepkg.go

@@ -33,7 +33,7 @@ import (
 
 func compilePkg(args []string) error {
 	// Parse arguments.
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}
@@ -446,13 +446,12 @@ func runNogo(ctx context.Context, workDir string, nogoPath string, srcs []string
 	args = append(args, "-x", outFactsPath)
 	args = append(args, srcs...)
 
-	paramFile := filepath.Join(workDir, "nogo.param")
-	params := strings.Join(args[1:], "\n")
-	if err := ioutil.WriteFile(paramFile, []byte(params), 0666); err != nil {
-		return fmt.Errorf("error writing nogo paramfile: %v", err)
+	paramsFile := filepath.Join(workDir, "nogo.param")
+	if err := writeParamsFile(paramsFile, args[1:]); err != nil {
+		return fmt.Errorf("error writing nogo params file: %v", err)
 	}
 
-	cmd := exec.CommandContext(ctx, args[0], "-param="+paramFile)
+	cmd := exec.CommandContext(ctx, args[0], "-param="+paramsFile)
 	out := &bytes.Buffer{}
 	cmd.Stdout, cmd.Stderr = out, out
 	if err := cmd.Run(); err != nil {

go/tools/builders/cover.go

@@ -28,7 +28,7 @@ import (
 // cover transforms a source file with "go tool cover". It is invoked by the
 // Go rules as an action.
 func cover(args []string) error {
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}

go/tools/builders/env.go

@@ -169,11 +169,10 @@ func runAndLogCommand(cmd *exec.Cmd, verbose bool) error {
 	return nil
 }
 
-// readParamsFile looks for arguments in args of the form
+// expandParamsFiles looks for arguments in args of the form
 // "-param=filename". When it finds these arguments it reads the file "filename"
-// and replaces the argument with its content (each argument must be on a
-// separate line; blank lines are ignored).
-func readParamsFiles(args []string) ([]string, error) {
+// and replaces the argument with its content.
+func expandParamsFiles(args []string) ([]string, error) {
 	var paramsIndices []int
 	for i, arg := range args {
 		if strings.HasPrefix(arg, "-param=") {
@@ -190,21 +189,86 @@ func readParamsFiles(args []string) ([]string, error) {
 		last = pi + 1
 
 		fileName := args[pi][len("-param="):]
-		content, err := ioutil.ReadFile(fileName)
+		fileArgs, err := readParamsFile(fileName)
 		if err != nil {
 			return nil, err
 		}
-		fileArgs := strings.Split(string(content), "\n")
-		if len(fileArgs) >= 0 && fileArgs[len(fileArgs)-1] == "" {
-			// Ignore final empty line.
-			fileArgs = fileArgs[:len(fileArgs)-1]
-		}
 		expandedArgs = append(expandedArgs, fileArgs...)
 	}
 	expandedArgs = append(expandedArgs, args[last:]...)
 	return expandedArgs, nil
 }
 
+// readParamsFiles parses a Bazel params file in "shell" format. The file
+// should contain one argument per line. Arguments may be quoted with single
+// quotes. All characters within quoted strings are interpreted literally
+// including newlines and excepting single quotes. Characters outside quoted
+// strings may be escaped with a backslash.
+func readParamsFile(name string) ([]string, error) {
+	data, err := ioutil.ReadFile(name)
+	if err != nil {
+		return nil, err
+	}
+
+	var args []string
+	var arg []byte
+	quote := false
+	escape := false
+	for p := 0; p < len(data); p++ {
+		b := data[p]
+		switch {
+		case escape:
+			arg = append(arg, b)
+			escape = false
+
+		case b == '\'':
+			quote = !quote
+
+		case !quote && b == '\\':
+			escape = true
+
+		case !quote && b == '\n':
+			args = append(args, string(arg))
+			arg = arg[:0]
+
+		default:
+			arg = append(arg, b)
+		}
+	}
+	if quote {
+		return nil, fmt.Errorf("unterminated quote")
+	}
+	if escape {
+		return nil, fmt.Errorf("unterminated escape")
+	}
+	if len(arg) > 0 {
+		args = append(args, string(arg))
+	}
+	return args, nil
+}
+
+// writeParamsFile formats a list of arguments in Bazel's "shell" format and writes
+// it to a file.
+func writeParamsFile(path string, args []string) error {
+	buf := new(bytes.Buffer)
+	for _, arg := range args {
+		if !strings.ContainsAny(arg, "'\n\\") {
+			fmt.Fprintln(buf, arg)
+			continue
+		}
+		buf.WriteByte('\'')
+		for _, r := range arg {
+			if r == '\'' {
+				buf.WriteString(`'\''`)
+			} else {
+				buf.WriteRune(r)
+			}
+		}
+		buf.WriteString("'\n")
+	}
+	return ioutil.WriteFile(path, buf.Bytes(), 0666)
+}
+
 // splitArgs splits a list of command line arguments into two parts: arguments
 // that should be interpreted by the builder (before "--"), and arguments
 // that should be passed through to the underlying tool (after "--").

go/tools/builders/generate_test_main.go

@@ -175,7 +175,7 @@ func main() {
 
 func genTestMain(args []string) error {
 	// Prepare our flags
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}

go/tools/builders/info.go

@@ -24,7 +24,7 @@ import (
 )
 
 func run(args []string) error {
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}

go/tools/builders/link.go

@@ -31,7 +31,7 @@ import (
 
 func link(args []string) error {
 	// Parse arguments.
-	args, err := readParamsFiles(args)
+	args, err := expandParamsFiles(args)
 	if err != nil {
 		return err
 	}