Thanks! A few things:

• We can't accept patches via issues. To contribute code, please see golang.org/doc/contribute.html
• It seems like a better fix might just be to store c in the scanner in case it is needed.
• Are there any benchmarks that cover this code? What is the impact on them, running with -benchmem? You'll want to use benchcmp to compare them.

Thanks, I don't think that code is fit for contribution though. I will provide a benchmark to reproduce the issue as soon as I can isolate it.

The benchmark is pretty trivial, but reproducing the allocations seems to require unmarshalling into a struct. I wasn't able to reproduce using an empty interface.

I went to http://www.json.org/example.html got a large sample of a JSON object, pasted it into https://mholt.github.io/json-to-go/ to generate a struct. Then the benchmark is simply:

func BenchmarkJSON(b *testing.B) {
    var o Autogenerated
    for n := 0; n < b.N; n++ {
        for i := 0; i < 1000; i++ {
            err := json.Unmarshal([]byte(testJSON), &o)
            if err != nil {
                b.Fatal(err)
            }
        }
    }
}

$ benchcmp old.txt new.txt 
benchmark         old ns/op     new ns/op     delta
BenchmarkJSON     133828654     137355079     +2.64%

benchmark         old allocs     new allocs     delta
BenchmarkJSON     161100         63083          -60.84%

benchmark         old bytes     new bytes     delta
BenchmarkJSON     6981457       5524665       -20.87%

I wish I had more time to work on this and properly contribute a fix, but I unfortunately don't. Apologies, this is the best I can do right now.

No worries, and thanks, this is useful as-is.

Here's a smaller, self-contained benchmark for whoever looks at this. (Not me.) The newline in the byte slice is important.

func BenchmarkIssue10335(b *testing.B) {
    b.ReportAllocs()
    var s struct{}
    j := []byte(`{"a":{
}}`)
    for n := 0; n < b.N; n++ {
        if err := Unmarshal(j, &s); err != nil {
            b.Fatal(err)
        }
    }
}

With the hack above:

benchmark               old ns/op     new ns/op     delta
BenchmarkIssue10335     1744          1028          -41.06%

benchmark               old allocs     new allocs     delta
BenchmarkIssue10335     10             4              -60.00%

benchmark               old bytes     new bytes     delta
BenchmarkIssue10335     432           288           -33.33%

Sent https://go-review.googlesource.com/8401

FWIW, I did a little experimentation with this yesterday and found that this input should also showcase the problem:

[]byte(`{"a":{ }}`)`

The newline in the input isn't the significant part, it's the fact that the two closing braces have no whitespace between them.

Thanks, @potocnyj. You're right. To reproduce, you need both whitespace (newline or space as you have it) as well as the two closing braces next to each other.

I retracted my change.

@josharian
Pushed a fix: https://go-review.googlesource.com/#/c/9074/

CL https://golang.org/cl/9074 mentions this issue.

CL https://golang.org/cl/33276 mentions this issue.