Revert "encoding/jsonschema: pass comments to DefineSchema"

This reverts https://cuelang.org/cl/1209259.

Unity CI is still broken a full day after we intentionally broke it
with this experimental API breaking change affecting the services repo.

I need to continue pairing with Roger to be able to update Unity
to test the latest version of the services repo without failing.
But we don't need to keep CI broken while we do that.

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

Author: mvdan

Diff for: encoding/jsonschema/decode.go

@@ -101,9 +101,6 @@ type definedSchema struct {
 	// schema holds the actual syntax for the schema. This
 	// is nil if the entry was created by a reference only.
 	schema ast.Expr
-
-	// comment holds any doc comment associated with the above schema.
-	comment *ast.CommentGroup
 }
 
 // addImport registers
@@ -218,7 +215,7 @@ func (d *decoder) decode(v cue.Value) *ast.File {
 		// have been mapped to an external location.
 		for _, def := range d.defs {
 			if def.schema != nil && def.importPath != "" {
-				d.cfg.DefineSchema(def.importPath, def.path, def.schema, def.comment)
+				d.cfg.DefineSchema(def.importPath, def.path, def.schema)
 			}
 		}
 	}
@@ -752,7 +749,7 @@ func (s *state) schema(n cue.Value) ast.Expr {
 // schemaState returns a new state value derived from s.
 // n holds the JSONSchema node to translate to a schema.
 // types holds the set of possible types that the value can hold.
-func (s0 *state) schemaState(n cue.Value, types cue.Kind) (expr ast.Expr, info schemaInfo) {
+func (s0 *state) schemaState(n cue.Value, types cue.Kind) (expr ast.Expr, ingo schemaInfo) {
 	s := &state{
 		up: s0,
 		schemaInfo: schemaInfo{
@@ -766,7 +763,7 @@ func (s0 *state) schemaState(n cue.Value, types cue.Kind) (expr ast.Expr, info s
 	}
 	defer func() {
 		// Perhaps replace the schema expression with a reference.
-		expr = s.maybeDefine(expr, info)
+		expr = s.maybeDefine(expr)
 	}()
 	if n.Kind() == cue.BoolKind {
 		if vfrom(VersionDraft6).contains(s.schemaVersion) {
@@ -850,13 +847,12 @@ func (s0 *state) schemaState(n cue.Value, types cue.Kind) (expr ast.Expr, info s
 // it just returns expr itself.
 // TODO also report whether the schema has been defined at a place
 // where it can be unified with something else?
-func (s *state) maybeDefine(expr ast.Expr, info schemaInfo) ast.Expr {
+func (s *state) maybeDefine(expr ast.Expr) ast.Expr {
 	def := s.definedSchemaForNode(s.pos)
 	if def == nil || len(def.path.Selectors()) == 0 {
 		return expr
 	}
 	def.schema = expr
-	def.comment = info.comment()
 	if def.importPath == "" {
 		// It's a local definition that's not at the root.
 		if !s.builder.put(def.path, expr, s.comment()) {

Diff for: encoding/jsonschema/decode_test.go

@@ -337,11 +337,7 @@ func TestMapRefExternalRefForInternalSchema(t *testing.T) {
 	v := cuecontext.New().CompileString(`
 type: "object"
 $id: "https://this.test"
-$defs: foo: {
-	description: "foo can be a number or a string"
-	type: ["number", "string"]
-}
-$defs: bar: type: "boolean"
+$defs: foo: type: ["number", "string"]
 $ref: "#/$defs/foo"
 `)
 	var calls []string
@@ -351,19 +347,14 @@ $ref: "#/$defs/foo"
 			calls = append(calls, loc.String())
 			switch loc.ID.String() {
 			case "https://this.test#/$defs/foo":
-				return "otherpkg.example/foo", cue.ParsePath("#x"), nil
-			case "https://this.test#/$defs/bar":
-				return "otherpkg.example/bar", cue.ParsePath("#x"), nil
+				return "otherpkg.example/foo", cue.ParsePath("#foo"), nil
 			case "https://this.test":
 				return "", cue.Path{}, nil
 			}
 			t.Errorf("unexpected ID")
 			return "", cue.Path{}, fmt.Errorf("unexpected ID %q passed to MapRef", loc.ID)
 		},
-		DefineSchema: func(importPath string, path cue.Path, e ast.Expr, c *ast.CommentGroup) {
-			if c != nil {
-				ast.AddComment(e, c)
-			}
+		DefineSchema: func(importPath string, path cue.Path, e ast.Expr) {
 			data, err := format.Node(e)
 			if err != nil {
 				t.Errorf("cannot format: %v", err)
@@ -377,22 +368,20 @@ $ref: "#/$defs/foo"
 	if err != nil {
 		t.Fatal(errors.Details(err, nil))
 	}
-	qt.Check(t, qt.DeepEquals(calls, []string{
+	qt.Assert(t, qt.DeepEquals(calls, []string{
 		"id=https://this.test#/$defs/foo localPath=$defs.foo",
-		"id=https://this.test#/$defs/bar localPath=$defs.bar",
 		"id=https://this.test localPath=",
 	}))
-	qt.Check(t, qt.Equals(string(b), `
+	qt.Assert(t, qt.Equals(string(b), `
 import "otherpkg.example/foo"
 
 @jsonschema(id="https://this.test")
-foo.#x & {
+foo.#foo & {
 	...
 }
 `[1:]))
-	qt.Check(t, qt.DeepEquals(defines, map[string]string{
-		"otherpkg.example/bar.#x": "bool",
-		"otherpkg.example/foo.#x": "// foo can be a number or a string\nnumber | string",
+	qt.Assert(t, qt.DeepEquals(defines, map[string]string{
+		"otherpkg.example/foo.#foo": "number | string",
 	}))
 }
 

Diff for: encoding/jsonschema/jsonschema.go

@@ -216,15 +216,15 @@ type Config struct {
 	// DefineSchema is called, if not nil, for any schema that is defined
 	// within the json schema being converted but is mapped somewhere
 	// external via [Config.MapRef]. The invoker of [Extract] is
-	// responsible for defining the schema in the correct place as described
+	// responsible for defining the schema e in the correct place as described
 	// by the import path and its relative CUE path.
 	//
 	// The importPath and path are exactly as returned by [Config.MapRef].
 	// If this or [Config.MapRef] is nil this function will never be called.
 	// Note that importPath will never be empty, because if MapRef
 	// returns an empty importPath, it's specifying an internal schema
 	// which will be defined accordingly.
-	DefineSchema func(importPath string, path cue.Path, e ast.Expr, docComment *ast.CommentGroup)
+	DefineSchema func(importPath string, path cue.Path, e ast.Expr)
 
 	// TODO: configurability to make it compatible with OpenAPI, such as
 	// - locations of definitions: #/components/schemas, for instance.