encoding/gocode: don't require output to be stable

gocode generates a Go variable cuegenInstanceData whose value is a
string containing CUE values encoded via Runtime.Marshal.
Said Marshal method encodes data via encoding/gob
and then compresses the encoded gob with compress/gzip.

This is perfectly fine, but the result isn't guaranteed to be stable
byte-by-byte between Go versions, since the gob format evolves
and gzip may get better at compressing data over time.

In particular, in Go 1.21, https://go.dev/cl/460543 changed the encoding
slightly by having the first user type be registered in encoding/gob
with type id 64 rather than 65. Given that encoding/gob had had
a constant `const firstUserId = 64` for a long time,
we assume that user types starting with type ID 65 was a minor mistake.

That upstream change shouldn't break any reasonable gob user.
However, we were expecting encoding/gob's output to be perfectly stable,
which is certainly not reasonable to do.

The tests in gen_test.go already import generated Go code in testdata,
so we do cover whether the generated code does what we expect it to.
We thus don't really need to check the output is stable,
we just need a way to update the output files in testdata as needed.
For that purpose, `go generate` is perfectly fine.

Signed-off-by: Daniel Martí <[email protected]>
Change-Id: I24b85c8c648a573ccca3c670f320f7e91278046e
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1167483
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Paul Jolly <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: mvdan

encoding/gocode/doc.go

@@ -12,6 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+//go:generate go run testdata/gen.go
+
 // Package gocode defines functions for extracting CUE definitions from Go code
 // and generating Go code from CUE values.
 //

encoding/gocode/gen_test.go

@@ -17,9 +17,12 @@
 package gocode
 
 import (
+	"bytes"
+	"regexp"
 	"strings"
 	"testing"
 
+	"cuelang.org/go/cue/errors"
 	"cuelang.org/go/encoding/gocode/testdata/pkg1"
 	"cuelang.org/go/encoding/gocode/testdata/pkg2"
 )
@@ -107,3 +110,13 @@ O.P: invalid value 4 (out of bound >5):
 		})
 	}
 }
+
+func errStr(err error) string {
+	if err == nil {
+		return "nil"
+	}
+	buf := &bytes.Buffer{}
+	errors.Print(buf, err, nil)
+	r := regexp.MustCompile(`.cue:\d+:\d+`)
+	return r.ReplaceAllString(buf.String(), ".cue:x:x")
+}

encoding/gocode/generator_test.go

@@ -0,0 +1,66 @@
+// Copyright 2019 CUE Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+
+	"cuelang.org/go/cue"
+	"cuelang.org/go/cue/load"
+	"cuelang.org/go/encoding/gocode"
+	_ "cuelang.org/go/pkg"
+)
+
+func main() {
+	dirs, err := ioutil.ReadDir("testdata")
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	cwd, err := os.Getwd()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	for _, d := range dirs {
+		if !d.IsDir() {
+			continue
+		}
+		dir := filepath.Join(cwd, "testdata")
+		pkg := "." + string(filepath.Separator) + d.Name()
+		inst := cue.Build(load.Instances([]string{pkg}, &load.Config{
+			Dir:        dir,
+			ModuleRoot: dir,
+			Module:     "cuelang.org/go/encoding/gocode/testdata",
+		}))[0]
+		if err := inst.Err; err != nil {
+			log.Fatal(err)
+		}
+
+		goPkg := "./testdata/" + d.Name()
+		b, err := gocode.Generate(goPkg, inst, nil)
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		goFile := filepath.Join("testdata", d.Name(), "cue_gen.go")
+		if err := os.WriteFile(goFile, b, 0644); err != nil {
+			log.Fatal(err)
+		}
+	}
+}