Work around long string concatenation with writeWrappedString

The compiler has trouble compiling the concatenation of many strings, s0 + s1 +
s2 + ... + sN, for large N. We insert redundant, explicit parentheses to work
around that, lowering the N at any given step.

This bug is golang/go#16394 and the fix is taken from golang/text@5c6cf4f9a2.

Fixes #8

Author: tmthrgd

issues_test.go

@@ -0,0 +1,77 @@
+// Copyright 2017 Tom Thorogood. All rights reserved.
+// Use of this source code is governed by a Modified
+// BSD License that can be found in the LICENSE file.
+
+package bindata
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"io/ioutil"
+	"os"
+	"os/exec"
+	"path"
+	"testing"
+	"time"
+)
+
+type loggerWriter struct{ testing.TB }
+
+func (w *loggerWriter) Write(p []byte) (n int, err error) {
+	w.Log(string(bytes.TrimRight(p, "\r\n")))
+	return len(p), nil
+}
+
+func TestIssue8(t *testing.T) {
+	// This test case covers https://github.com/tmthrgd/go-bindata/issues/8.
+	//
+	// It generates a file with ~43,000 string concatenations which
+	// triggers https://golang.org/issue/16394.
+
+	if testing.Short() {
+		t.Skip("skipping in short mode")
+	}
+
+	dir, err := ioutil.TempDir("", "go-bindata-test-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dir)
+
+	f, err := os.Create(path.Join(dir, "issue-8.go"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	if err = (Files{
+		&testFile{
+			path: "issue-8.bin",
+			size: 1 << 20,
+		},
+	}).Generate(f, &GenerateOptions{
+		Package: "main",
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err = io.WriteString(f, "\nfunc main() {}\n"); err != nil {
+		t.Fatal(err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+	defer cancel()
+
+	cmd := exec.CommandContext(ctx, "go", "build", ".")
+
+	cmd.Dir = dir
+	cmd.Env = os.Environ()
+
+	cmd.Stderr = &loggerWriter{t}
+	cmd.Stdout = cmd.Stderr
+
+	if err = cmd.Run(); err != nil {
+		t.Fatal(err)
+	}
+}

release.go

@@ -9,6 +9,7 @@ import (
 	"compress/flate"
 	"io"
 	"path"
+	"strings"
 	"sync"
 	"text/template"
 )
@@ -22,6 +23,8 @@ func writeWrappedString(write func(io.Writer) error, indent string, wrapAt int)
 		bufPool.Put(buf)
 	}()
 
+	buf.WriteString("(\"\" +\n")
+	buf.WriteString(indent)
 	buf.WriteByte('"')
 
 	if err := write(&stringWriter{
@@ -32,8 +35,15 @@ func writeWrappedString(write func(io.Writer) error, indent string, wrapAt int)
 		return "", err
 	}
 
-	buf.WriteByte('"')
-	return buf.String(), nil
+	buf.WriteString("\")")
+
+	s := buf.String()
+
+	if strings.IndexByte(s[1:], '(') == -1 {
+		s = s[1 : len(s)-1]
+	}
+
+	return s, nil
 }
 
 func init() {
@@ -209,11 +219,9 @@ var _bindata = map[string]*asset{
 		orig: {{printf "%q" .File.Name}},
 	{{- end}}
 		data: {{if $.Compress -}}
-			"" +
 			{{flate . "\t\t\t" 24}}
 		{{- else -}}
-			"" +
-			{{read . "\t\t\t" 24 -}}
+			{{read . "\t\t\t" 24}}
 		{{- end}},
 
 	{{- if or $.Metadata $.Compress -}}
@@ -234,8 +242,7 @@ var _bindata = map[string]*asset{
 	{{- end -}}
 
 	{{- if $.Hash}}
-		hash: "" +
-			{{wrap .Hash "\t\t\t" 24}},
+		hash: {{wrap .Hash "\t\t\t" 24}},
 	{{- end}}
 	},
 {{end -}}

stringwriter.go

@@ -7,15 +7,16 @@ package bindata
 import "io"
 
 var (
-	stringWriterLinePrefix = []byte(`"`)
-	stringWriterLineSuffix = []byte("\" +\n")
+	stringWriterLinePrefix       = []byte(`"`)
+	stringWriterLineSuffix       = []byte("\" +\n")
+	stringWriterParensLineSuffix = []byte("\") + (\"\" +\n")
 )
 
 type stringWriter struct {
 	io.Writer
 	Indent string
 	WrapAt int
-	c      int
+	c, l   int
 }
 
 func (w *stringWriter) Write(p []byte) (n int, err error) {
@@ -37,7 +38,23 @@ func (w *stringWriter) Write(p []byte) (n int, err error) {
 			continue
 		}
 
-		if _, err = w.Writer.Write(stringWriterLineSuffix); err != nil {
+		w.l++
+
+		suffix := stringWriterLineSuffix
+		if w.l%500 == 0 {
+			// As per https://golang.org/issue/18078, the compiler has trouble
+			// compiling the concatenation of many strings, s0 + s1 + s2 + ... + sN,
+			// for large N. We insert redundant, explicit parentheses to work around
+			// that, lowering the N at any given step: (s0 + s1 + ... + s499) + (s500 +
+			// ... + s1999) + etc + (etc + ... + sN).
+			//
+			// This fix was taken from the fix applied to x/text in
+			// https://github.com/golang/text/commit/5c6cf4f9a2.
+
+			suffix = stringWriterParensLineSuffix
+		}
+
+		if _, err = w.Writer.Write(suffix); err != nil {
 			return
 		}