fix: Proper handling of clashing types case

fixtures/clashing_types.json

@@ -0,0 +1,123 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://github.com/invopop/jsonschema/odd",
+  "$ref": "#/$defs/Odd",
+  "$defs": {
+    "Dummy": {
+      "properties": {
+        "A": {
+          "type": "string"
+        },
+        "Dummy": {
+          "$ref": "#/$defs/Dummy-1"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "A",
+        "Dummy"
+      ]
+    },
+    "Dummy-1": {
+      "properties": {
+        "A": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "A"
+      ]
+    },
+    "Dummy-2": {
+      "properties": {
+        "B": {
+          "type": "integer"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "B"
+      ]
+    },
+    "GrandfatherType": {
+      "properties": {
+        "family_name": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "family_name"
+      ]
+    },
+    "Odd": {
+      "properties": {
+        "id": {
+          "type": "string"
+        },
+        "some_base_property": {
+          "type": "integer"
+        },
+        "grand": {
+          "$ref": "#/$defs/GrandfatherType"
+        },
+        "SomeUntaggedBaseProperty": {
+          "type": "boolean"
+        },
+        "internal": {
+          "$ref": "#/$defs/Odd-1"
+        },
+        "link": {
+          "$ref": "#/$defs/Odd"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "id",
+        "some_base_property",
+        "grand",
+        "SomeUntaggedBaseProperty",
+        "internal",
+        "link"
+      ]
+    },
+    "Odd-1": {
+      "properties": {
+        "Dummy1": {
+          "$ref": "#/$defs/Dummy"
+        },
+        "Dummy1a": {
+          "$ref": "#/$defs/Dummy"
+        },
+        "Dummy2": {
+          "$ref": "#/$defs/Dummy-1"
+        },
+        "Dummy2a": {
+          "$ref": "#/$defs/Dummy-1"
+        },
+        "Dummy3": {
+          "$ref": "#/$defs/Dummy-2"
+        },
+        "Dummy3a": {
+          "$ref": "#/$defs/Dummy-2"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "Dummy1",
+        "Dummy1a",
+        "Dummy2",
+        "Dummy2a",
+        "Dummy3",
+        "Dummy3a"
+      ]
+    }
+  }
+}

fixtures/shadowed_clashing_types.json

@@ -0,0 +1,51 @@
+{
+  "$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"
+        },
+        "pkg_link": {
+          "$ref": "#/$defs/GrandfatherType-1"
+        }
+      },
+      "additionalProperties": false,
+      "type": "object",
+      "required": [
+        "odd",
+        "link",
+        "pkg_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"
+      ]
+    }
+  }
+}

internal/testdata/odd.go

@@ -0,0 +1,22 @@
+package testdata
+
+import (
+	"github.com/invopop/jsonschema/internal/testdata/types"
+	"github.com/invopop/jsonschema/internal/testdata/types/deeper"
+)
+
+type (
+	Odd struct {
+		Dummy1  types.Dummy
+		Dummy1a types.Dummy
+
+		Dummy2  deeper.Dummy
+		Dummy2a deeper.Dummy
+
+		Dummy3  Dummy
+		Dummy3a Dummy
+	}
+	Dummy struct {
+		B int
+	}
+)

internal/testdata/types/deeper/dummy.go

@@ -0,0 +1,5 @@
+package deeper
+
+type Dummy struct {
+	A string
+}

internal/testdata/types/dummy.go

@@ -0,0 +1,8 @@
+package types
+
+import "github.com/invopop/jsonschema/internal/testdata/types/deeper"
+
+type Dummy struct {
+	A     string
+	Dummy deeper.Dummy
+}

reflect.go

@@ -573,7 +573,10 @@ 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) {
-	name := r.typeName(t)
+	// we save both type & pkg info to match against reflected type later
+	s._type = t
+
+	_, name := r.findDef(definitions, t)
 	if name == "" {
 		return
 	}
@@ -585,18 +588,48 @@ func (r *Reflector) refDefinition(definitions Definitions, t reflect.Type) *Sche
 	if r.DoNotReference {
 		return nil
 	}
-	name := r.typeName(t)
-	if name == "" {
-		return nil
-	}
-	if _, ok := definitions[name]; !ok {
+
+	def, name := r.findDef(definitions, t)
+	if def == nil {
+		// no entry present in definitions
+		// This is also true if name == "" (~ r.typeName() == "")
 		return nil
 	}
 	return &Schema{
 		Ref: "#/$defs/" + name,
 	}
 }
 
+// findDef returns the matching definition for the passed reflect.Type
+// It will add suffix like `_idx` if necessary & return the corresponding key as well.
+// If no applicable entry is available, it will return nil & the key available to use.
+func (r *Reflector) findDef(definitions Definitions, t reflect.Type) (*Schema, string) {
+	name := r.typeName(t)
+	if name == "" {
+		return nil, ""
+	}
+
+	defName := name
+	for idx := 1; ; idx++ {
+		def, ok := definitions[defName]
+		if !ok {
+			return nil, defName
+		}
+		if sameReflectTypes(def._type, t) {
+			return def, defName
+		}
+		defName = name + "-" + strconv.Itoa(idx)
+	}
+}
+
+func sameReflectTypes(a, b reflect.Type) bool {
+	if fullyQualifiedTypeName(a) != fullyQualifiedTypeName(b) {
+		return false
+	}
+
+	return a.AssignableTo(b) && b.AssignableTo(a)
+}
+
 func (r *Reflector) lookupID(t reflect.Type) ID {
 	if r.Lookup != nil {
 		if t.Kind() == reflect.Ptr {

reflect_test.go

@@ -14,7 +14,7 @@ import (
 	"time"
 
 	"github.com/invopop/jsonschema/examples"
-
+	"github.com/invopop/jsonschema/internal/testdata"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -657,3 +657,33 @@ func TestJSONSchemaAlias(t *testing.T) {
 	compareSchemaOutput(t, "fixtures/schema_alias.json", r, &AliasObjectB{})
 	compareSchemaOutput(t, "fixtures/schema_alias_2.json", r, &AliasObjectC{})
 }
+
+func TestClashingTypes(t *testing.T) {
+	type Odd struct {
+		SomeBaseType
+		Internal testdata.Odd `json:"internal"`
+		Link     *Odd         `json:"link"`
+	}
+
+	r := &Reflector{}
+	compareSchemaOutput(t, "fixtures/clashing_types.json", r, &Odd{})
+}
+
+func TestShadowedClashingTypes(t *testing.T) {
+	type (
+		Odd struct {
+			Base GrandfatherType `json:"base"`
+		}
+		GrandfatherTypePtr *GrandfatherType
+	)
+
+	{
+		type GrandfatherType struct {
+			Odd     Odd                `json:"odd"`
+			Link    *GrandfatherType   `json:"link"`
+			PkgLink GrandfatherTypePtr `json:"pkg_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"
 )
@@ -79,6 +80,9 @@ type Schema struct {
 
 	// Special boolean representation of the Schema - section 4.3.2
 	boolean *bool
+
+	// _type is used to define whether the looked-up definition points to the proper type or not
+	_type reflect.Type
 }
 
 var (