remove 3 fields

Author: jba

jsonschema/resolve.go

@@ -25,6 +25,22 @@ type Resolved struct {
 	root *Schema
 	// map from $ids to their schemas
 	resolvedURIs map[string]*Schema
+	// map from schemas to additional info computed during resolution
+	resolvedInfo map[*Schema]*resolvedInfo
+}
+
+// resolvedInfo holds information specific to a schema that is computed by [Schema.Resolve].
+type resolvedInfo struct {
+	s *Schema
+	// The schema to which Ref refers.
+	resolvedRef *Schema
+
+	// If the schema has a dynamic ref, exactly one of the next two fields
+	// will be non-zero after successful resolution.
+	// The schema to which the dynamic ref refers when it acts lexically.
+	resolvedDynamicRef *Schema
+	// The anchor to look up on the stack when the dynamic ref acts dynamically.
+	dynamicRefAnchor string
 }
 
 // Schema returns the schema that was resolved.
@@ -59,6 +75,8 @@ type ResolveOptions struct {
 // Resolve resolves all references within the schema and performs other tasks that
 // prepare the schema for validation.
 // If opts is nil, the default values are used.
+// The schema must not be changed after Resolve is called.
+// The same schema may be resolved multiple times.
 func (root *Schema) Resolve(opts *ResolveOptions) (*Resolved, error) {
 	// There are up to five steps required to prepare a schema to validate.
 	// 1. Load: read the schema from somewhere and unmarshal it.
@@ -71,9 +89,6 @@ func (root *Schema) Resolve(opts *ResolveOptions) (*Resolved, error) {
 	//    in a map from URIs to schemas within root.
 	// 4. Resolve references: all refs in the schemas are replaced with the schema they refer to.
 	// 5. (Optional.) If opts.ValidateDefaults is true, validate the defaults.
-	if root.path != "" {
-		return nil, fmt.Errorf("jsonschema: Resolve: %s already resolved", root)
-	}
 	r := &resolver{loaded: map[string]*Resolved{}}
 	if opts != nil {
 		r.opts = *opts
@@ -129,7 +144,8 @@ func (r *resolver) resolve(s *Schema, baseURI *url.URL) (*Resolved, error) {
 	if err != nil {
 		return nil, err
 	}
-	rs := &Resolved{root: s, resolvedURIs: m}
+	rs := &Resolved{root: s, resolvedURIs: m, resolvedInfo: map[*Schema]*resolvedInfo{}}
+
 	// Remember the schema by both the URI we loaded it from and its canonical name,
 	// which may differ if the schema has an $id.
 	// We must set the map before calling resolveRefs, or ref cycles will cause unbounded recursion.
@@ -161,6 +177,10 @@ func (root *Schema) check() error {
 // checkStructure verifies that root and its subschemas form a tree.
 // It also assigns each schema a unique path, to improve error messages.
 func (root *Schema) checkStructure() error {
+	if root.path != "" {
+		// We have done this before, and it will always produce the same result.
+		return nil
+	}
 	var check func(reflect.Value, []byte) error
 	check = func(v reflect.Value, path []byte) error {
 		// For the purpose of error messages, the root schema has path "root"
@@ -382,14 +402,17 @@ func resolveURIs(root *Schema, baseURI *url.URL) (map[string]*Schema, error) {
 // that needs to be loaded.
 func (r *resolver) resolveRefs(rs *Resolved) error {
 	for s := range rs.root.all() {
+		assert(rs.resolvedInfo[s] == nil, "schema resolved info already set")
+		info := &resolvedInfo{s: s}
+		rs.resolvedInfo[s] = info
 		if s.Ref != "" {
 			refSchema, _, err := r.resolveRef(rs, s, s.Ref)
 			if err != nil {
 				return err
 			}
 			// Whether or not the anchor referred to by $ref fragment is dynamic,
 			// the ref still treats it lexically.
-			s.resolvedRef = refSchema
+			info.resolvedRef = refSchema
 		}
 		if s.DynamicRef != "" {
 			refSchema, frag, err := r.resolveRef(rs, s, s.DynamicRef)
@@ -399,11 +422,11 @@ func (r *resolver) resolveRefs(rs *Resolved) error {
 			if frag != "" {
 				// The dynamic ref's fragment points to a dynamic anchor.
 				// We must resolve the fragment at validation time.
-				s.dynamicRefAnchor = frag
+				info.dynamicRefAnchor = frag
 			} else {
 				// There is no dynamic anchor in the lexically referenced schema,
 				// so the dynamic ref behaves like a lexical ref.
-				s.resolvedDynamicRef = refSchema
+				info.resolvedDynamicRef = refSchema
 			}
 		}
 	}
@@ -447,6 +470,13 @@ func (r *resolver) resolveRef(rs *Resolved, s *Schema, ref string) (_ *Schema, d
 			}
 			referencedSchema = lrs.root
 			assert(referencedSchema != nil, "nil referenced schema")
+			// Copy the resolvedInfos from lrs into rs, without overwriting
+			// (hence we can't use maps.Insert).
+			for s, i := range lrs.resolvedInfo {
+				if rs.resolvedInfo[s] == nil {
+					rs.resolvedInfo[s] = i
+				}
+			}
 		}
 	}
 

jsonschema/resolve_test.go

@@ -193,13 +193,14 @@ func TestRefCycle(t *testing.T) {
 	}
 
 	rs, err := schemas["root"].Resolve(&ResolveOptions{Loader: loader})
+	t.Logf("%#v", rs.resolvedInfo)
 	if err != nil {
 		t.Fatal(err)
 	}
 
 	check := func(s *Schema, key string) {
 		t.Helper()
-		if s.resolvedRef != schemas[key] {
+		if rs.resolvedInfo[s].resolvedRef != schemas[key] {
 			t.Errorf("%s resolvedRef != schemas[%q]", s.json(), key)
 		}
 	}

jsonschema/schema.go

@@ -151,16 +151,6 @@ type Schema struct {
 	// Used in errors.
 	path string
 
-	// The schema to which Ref refers.
-	resolvedRef *Schema
-
-	// If the schema has a dynamic ref, exactly one of the next two fields
-	// will be non-zero after successful resolution.
-	// The schema to which the dynamic ref refers when it acts lexically.
-	resolvedDynamicRef *Schema
-	// The anchor to look up on the stack when the dynamic ref acts dynamically.
-	dynamicRefAnchor string
-
 	// Map from anchors to subschemas.
 	anchors map[string]anchorInfo
 
@@ -200,13 +190,13 @@ func (s *Schema) String() string {
 	return "<anonymous schema>"
 }
 
-// ResolvedRef returns the Schema to which this schema's $ref keyword
-// refers, or nil if it doesn't have a $ref.
-// It returns nil if this schema has not been resolved, meaning that
-// [Schema.Resolve] was called on it or one of its ancestors.
-func (s *Schema) ResolvedRef() *Schema {
-	return s.resolvedRef
-}
+// // ResolvedRef returns the Schema to which this schema's $ref keyword
+// // refers, or nil if it doesn't have a $ref.
+// // It returns nil if this schema has not been resolved, meaning that
+// // [Schema.Resolve] was called on it or one of its ancestors.
+// func (s *Schema) ResolvedRef() *Schema {
+// 	return s.resolvedRef
+// }
 
 func (s *Schema) basicChecks() error {
 	if s.Type != "" && s.Types != nil {

jsonschema/validate.go

@@ -90,6 +90,8 @@ func (st *state) validate(instance reflect.Value, schema *Schema, callerAnns *an
 		instance = instance.Elem()
 	}
 
+	info := st.rs.resolvedInfo[schema]
+
 	// type: https://json-schema.org/draft/2020-12/draft-bhutton-json-schema-validation-01#section-6.1.1
 	if schema.Type != "" || schema.Types != nil {
 		gotType, ok := jsonType(instance)
@@ -185,19 +187,19 @@ func (st *state) validate(instance reflect.Value, schema *Schema, callerAnns *an
 
 	// $ref: https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.3.1
 	if schema.Ref != "" {
-		if err := st.validate(instance, schema.resolvedRef, &anns); err != nil {
+		if err := st.validate(instance, info.resolvedRef, &anns); err != nil {
 			return err
 		}
 	}
 
 	// $dynamicRef: https://json-schema.org/draft/2020-12/json-schema-core#section-8.2.3.2
 	if schema.DynamicRef != "" {
 		// The ref behaves lexically or dynamically, but not both.
-		assert((schema.resolvedDynamicRef == nil) != (schema.dynamicRefAnchor == ""),
+		assert((info.resolvedDynamicRef == nil) != (info.dynamicRefAnchor == ""),
 			"DynamicRef not resolved properly")
-		if schema.resolvedDynamicRef != nil {
+		if info.resolvedDynamicRef != nil {
 			// Same as $ref.
-			if err := st.validate(instance, schema.resolvedDynamicRef, &anns); err != nil {
+			if err := st.validate(instance, info.resolvedDynamicRef, &anns); err != nil {
 				return err
 			}
 		} else {
@@ -212,14 +214,14 @@ func (st *state) validate(instance reflect.Value, schema *Schema, callerAnns *an
 			// For an example, search for "detached" in testdata/draft2020-12/dynamicRef.json.
 			var dynamicSchema *Schema
 			for _, s := range st.stack {
-				info, ok := s.base.anchors[schema.dynamicRefAnchor]
+				info, ok := s.base.anchors[info.dynamicRefAnchor]
 				if ok && info.dynamic {
 					dynamicSchema = info.schema
 					break
 				}
 			}
 			if dynamicSchema == nil {
-				return fmt.Errorf("missing dynamic anchor %q", schema.dynamicRefAnchor)
+				return fmt.Errorf("missing dynamic anchor %q", info.dynamicRefAnchor)
 			}
 			if err := st.validate(instance, dynamicSchema, &anns); err != nil {
 				return err
@@ -554,10 +556,11 @@ func (st *state) resolveDynamicRef(schema *Schema) (*Schema, error) {
 	if schema.DynamicRef == "" {
 		return nil, nil
 	}
+	info := st.rs.resolvedInfo[schema]
 	// The ref behaves lexically or dynamically, but not both.
-	assert((schema.resolvedDynamicRef == nil) != (schema.dynamicRefAnchor == ""),
+	assert((info.resolvedDynamicRef == nil) != (info.dynamicRefAnchor == ""),
 		"DynamicRef not statically resolved properly")
-	if r := schema.resolvedDynamicRef; r != nil {
+	if r := info.resolvedDynamicRef; r != nil {
 		// Same as $ref.
 		return r, nil
 	}
@@ -571,12 +574,12 @@ func (st *state) resolveDynamicRef(schema *Schema) (*Schema, error) {
 	// on the stack.
 	// For an example, search for "detached" in testdata/draft2020-12/dynamicRef.json.
 	for _, s := range st.stack {
-		info, ok := s.base.anchors[schema.dynamicRefAnchor]
+		info, ok := s.base.anchors[info.dynamicRefAnchor]
 		if ok && info.dynamic {
 			return info.schema, nil
 		}
 	}
-	return nil, fmt.Errorf("missing dynamic anchor %q", schema.dynamicRefAnchor)
+	return nil, fmt.Errorf("missing dynamic anchor %q", info.dynamicRefAnchor)
 }
 
 // ApplyDefaults modifies an instance by applying the schema's defaults to it. If