Attributes with same name as type cause name conflicts

Inizia riproducendo il problema con lo schema Python Pydantic e ispeziona il percorso di generazione del codice che produce i tipi Rust mostrati. Traccia il modo in cui vengono assegnati i nomi alla struct e all'enum generati, quindi aggiungi una copertura di regressione per questo schema. Il lavoro è completo quando il Rust generato non dichiara più tipi in conflitto e rimane valido.

Sample JSON schema:

{
    "$defs": {
      "FirstType": {
        "properties": {
          "first": {
            "title": "First",
            "type": "string"
          }
        },
        "required": [
          "first"
        ],
        "title": "FirstType",
        "type": "object"
      },
      "SecondType": {
        "properties": {
          "second": {
            "title": "Second",
            "type": "string"
          }
        },
        "required": [
          "second"
        ],
        "title": "SecondType",
        "type": "object"
      }
    },
    "properties": {
      "test": {
        "anyOf": [
          {
            "$ref": "#/$defs/FirstType"
          },
          {
            "$ref": "#/$defs/SecondType"
          },
          {
            "type": "null"
          }
        ],
        "title": "Test"
      }
    },
    "required": [
      "test"
    ],
    "title": "Test",
    "type": "object"
  }

This is the JSON schema of this simple class structure (sample code in Python):

import json
from pydantic import BaseModel

class FirstType(BaseModel):
    first: str

class SecondType(BaseModel):
    second: str

class Test(BaseModel):
    test: FirstType | SecondType | None

test_json = Test.model_json_schema()

print(json.dumps(test_json, indent=2))

This results in the following generated schema from using typify. I have only included the important parts:

pub struct Test {
    pub test: Test,
}
impl ::std::convert::From<&Test> for Test {
    fn from(value: &Test) -> Self {
        value.clone()
    }
}
impl Test {
    pub fn builder() -> builder::Test {
        Default::default()
    }
}
pub enum Test {
    Variant0(FirstType),
    Variant1(SecondType),
    Variant2,
}
impl ::std::convert::From<&Self> for Test {
    fn from(value: &Test) -> Self {
        value.clone()
    }
}
impl ::std::convert::From<FirstType> for Test {
    fn from(value: FirstType) -> Self {
        Self::Variant0(value)
    }
}
impl ::std::convert::From<SecondType> for Test {
    fn from(value: SecondType) -> Self {
        Self::Variant1(value)
    }
}

Obviously, you can't have an enum and a struct with the same name (enum Test and struct Test).