resolve shadowing

fixtures/shadowed_clashing_types.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/invopop/jsonschema/grandfather-type",
+  "$ref": "#/$defs/GrandfatherType",
+  "$defs": {
+    "GrandfatherType": {
+      "properties": {
+        "odd": {
+          "$ref": "#/$defs/Odd"
+        },
+        "link": {
+          "$ref": "#/$defs/GrandfatherType"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "odd",
+        "link"
+      ]
+    },
+    "GrandfatherType_1": {
+      "properties": {
+        "family_name": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "family_name"
+      ]
+    },
+    "Odd": {
+      "properties": {
+        "base": {
+          "$ref": "#/$defs/GrandfatherType_1"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "base"
+      ]
+    }
+  }
+}

reflect.go

@@ -574,7 +574,7 @@ func (r *Reflector) lookupComment(t reflect.Type, name string) string {
 // addDefinition will append the provided schema. If needed, an ID and anchor will also be added.
 func (r *Reflector) addDefinition(definitions Definitions, t reflect.Type, s *Schema) {
 	// we save both type & pkg info to match against reflected type later
-	s.sourceType = fullyQualifiedTypeName(t)
+	s._type = t
 
 	_, name := r.findDef(definitions, t)
 	if name == "" {
@@ -608,21 +608,32 @@ func (r *Reflector) findDef(definitions Definitions, t reflect.Type) (*Schema, s
 	if name == "" {
 		return nil, ""
 	}
-	sourceType := fullyQualifiedTypeName(t)
 
 	defName := name
 	for idx := 1; ; idx++ {
 		def, ok := definitions[defName]
 		if !ok {
 			return nil, defName
 		}
-		if def.sourceType == sourceType {
+		if sameReflectTypes(def._type, t) {
 			return def, defName
 		}
 		defName = name + "_" + strconv.Itoa(idx)
 	}
 }
 
+func sameReflectTypes(a, b reflect.Type) bool {
+	if a.Kind() != b.Kind() {
+		return false
+	}
+
+	if fullyQualifiedTypeName(a) != fullyQualifiedTypeName(b) {
+		return false
+	}
+
+	return a.ConvertibleTo(b) && b.ConvertibleTo(a)
+}
+
 func (r *Reflector) lookupID(t reflect.Type) ID {
 	if r.Lookup != nil {
 		if t.Kind() == reflect.Ptr {

reflect_test.go

@@ -668,3 +668,18 @@ func TestClashingTypes(t *testing.T) {
 	r := &Reflector{}
 	compareSchemaOutput(t, "fixtures/clashing_types.json", r, &Odd{})
 }
+
+func TestShadowedClashingTypes(t *testing.T) {
+	type Odd struct {
+		Base GrandfatherType `json:"base"`
+	}
+
+	{
+		type GrandfatherType struct {
+			Odd  Odd              `json:"odd"`
+			Link *GrandfatherType `json:"link"`
+		}
+		r := &Reflector{}
+		compareSchemaOutput(t, "fixtures/shadowed_clashing_types.json", r, &GrandfatherType{})
+	}
+}

schema.go

@@ -2,6 +2,7 @@ package jsonschema
 
 import (
 	"encoding/json"
+	"reflect"
 
 	orderedmap "github.com/wk8/go-ordered-map/v2"
 )
@@ -80,8 +81,8 @@ type Schema struct {
 	// Special boolean representation of the Schema - section 4.3.2
 	boolean *bool
 
-	// sourceType is used to define whether the looked-up definition points to the proper type or not
-	sourceType string
+	// _type is used to define whether the looked-up definition points to the proper type or not
+	_type reflect.Type
 }
 
 var (