Single entry allOf ref type is possible to "guess" referenced model type

[FilipKrawiec]

Is your feature request related to a problem? Please describe.
When $ref property is nested into allOf schema array, type is evaluated as dynamic even it is the only one ref entry.

          "address": {
            "allOf": [
              {
                "$ref": "#/components/schemas/Address"
              },
              {
                "title": "Address",
                "description": "Address usable to send some documents via post",
                "nullable": true
              }
            ]
          },

To Reproduce
Please attach swagger and code snippet of generated value

Schema:

{
  "paths": {
    "/v1/churches": {
      "post": {
        "tags": [
          "Church Controller"
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AddChurchRequestBody"
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "OK",
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/Unit"
                }
              }
            }
          },
          "401": {
            "description": "Not Authorized"
          },
          "403": {
            "description": "Not Allowed"
          }
        }
      }
    }
  },
  "components": {
    "schemas": {
      "AddChurchRequestBody": {
        "description": "Include all required fields to add new church to system",
        "required": [
          "cin",
          "name",
          "address",
          "email",
          "phoneNumber",
          "website"
        ],
        "type": "object",
        "properties": {
          "cin": {
            "pattern": "^((AT)?U[0-9]{8}|(BE)?0[0-9]{9}|(BG)?[0-9]{9,10}|(CY)?[0-9]{8}L|(CZ)?[0-9]{8,10}|(DE)?[0-9]{9}|(DK)?[0-9]{8}|(EE)?[0-9]{9}|(EL|GR)?[0-9]{9}|(ES)?[0-9A-Z][0-9]{7}[0-9A-Z]|(FI)?[0-9]{8}|(FR)?[0-9A-Z]{2}[0-9]{9}|(GB)?([0-9]{9}([0-9]{3})?|[A-Z]{2}[0-9]{3})|(HU)?[0-9]{8}|(IE)?[0-9]S[0-9]{5}L|(IT)?[0-9]{11}|(LT)?([0-9]{9}|[0-9]{12})|(LU)?[0-9]{8}|(LV)?[0-9]{11}|(MT)?[0-9]{8}|(NL)?[0-9]{9}B[0-9]{2}|(PL)?[0-9]{10}|(PT)?[0-9]{9}|(RO)?[0-9]{2,10}|(SE)?[0-9]{12}|(SI)?[0-9]{8}|(SK)?[0-9]{10})$",
            "type": "string",
            "nullable": true
          },
          "name": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          },
          "address": {
            "allOf": [
              {
                "$ref": "#/components/schemas/Address"
              },
              {
                "nullable": true
              }
            ]
          },
          "email": {
            "pattern": "(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)])",
            "type": "string",
            "nullable": true
          },
          "phoneNumber": {
            "pattern": "^\\+\\d{10,12}$",
            "type": "string",
            "nullable": true
          },
          "website": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          }
        }
      },
      "Address": {
        "description": "Value object used to localize person or church via post or GPS",
        "required": [
          "geolocation",
          "country",
          "street",
          "streetNumber",
          "city",
          "postalCode"
        ],
        "type": "object",
        "properties": {
          "geolocation": {
            "allOf": [
              {
                "$ref": "#/components/schemas/Geolocation"
              },
              {
                "nullable": true
              }
            ]
          },
          "country": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          },
          "street": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          },
          "streetNumber": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          },
          "city": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          },
          "postalCode": {
            "pattern": "\\S",
            "type": "string",
            "nullable": true
          }
        }
      },
      "Geolocation": {
        "description": "GPS coordination",
        "required": [
          "latitude",
          "longitude"
        ],
        "type": "object",
        "properties": {
          "latitude": {
            "format": "double",
            "maximum": 180,
            "minimum": -180,
            "type": "number",
            "nullable": true
          },
          "longitude": {
            "format": "double",
            "maximum": 90,
            "minimum": -90,
            "type": "number",
            "nullable": true
          }
        }
      }
    }
  }
}

Generated model:

@JsonSerializable(explicitToJson: true)
class AddChurchRequestBody {
  AddChurchRequestBody({
    required this.cin,
    required this.name,
    required this.address,
    required this.email,
    required this.phoneNumber,
    required this.website,
  });

  factory AddChurchRequestBody.fromJson(Map<String, dynamic> json) =>
      _$AddChurchRequestBodyFromJson(json);

  @JsonKey(name: 'cin')
  final String? cin;
  @JsonKey(name: 'name')
  final String? name;
  @JsonKey(name: 'address')
  final dynamic address;
  @JsonKey(name: 'email')
  final String? email;
  @JsonKey(name: 'phoneNumber')
  final String? phoneNumber;
  @JsonKey(name: 'website')
  final String? website;
  static const fromJsonFactory = _$AddChurchRequestBodyFromJson;
  static const toJsonFactory = _$AddChurchRequestBodyToJson;
  Map<String, dynamic> toJson() => _$AddChurchRequestBodyToJson(this);

  @override
  bool operator ==(dynamic other) {
    return identical(this, other) ||
        (other is AddChurchRequestBody &&
            (identical(other.cin, cin) ||
                const DeepCollectionEquality().equals(other.cin, cin)) &&
            (identical(other.name, name) ||
                const DeepCollectionEquality().equals(other.name, name)) &&
            (identical(other.address, address) ||
                const DeepCollectionEquality()
                    .equals(other.address, address)) &&
            (identical(other.email, email) ||
                const DeepCollectionEquality().equals(other.email, email)) &&
            (identical(other.phoneNumber, phoneNumber) ||
                const DeepCollectionEquality()
                    .equals(other.phoneNumber, phoneNumber)) &&
            (identical(other.website, website) ||
                const DeepCollectionEquality().equals(other.website, website)));
  }

  @override
  String toString() => jsonEncode(this);

  @override
  int get hashCode =>
      const DeepCollectionEquality().hash(cin) ^
      const DeepCollectionEquality().hash(name) ^
      const DeepCollectionEquality().hash(address) ^
      const DeepCollectionEquality().hash(email) ^
      const DeepCollectionEquality().hash(phoneNumber) ^
      const DeepCollectionEquality().hash(website) ^
      runtimeType.hashCode;
}

@JsonSerializable(explicitToJson: true)
class Address {
  Address({
    required this.geolocation,
    required this.country,
    required this.street,
    required this.streetNumber,
    required this.city,
    required this.postalCode,
  });

  factory Address.fromJson(Map<String, dynamic> json) =>
      _$AddressFromJson(json);

  @JsonKey(name: 'geolocation')
  final dynamic geolocation;
  @JsonKey(name: 'country')
  final String? country;
  @JsonKey(name: 'street')
  final String? street;
  @JsonKey(name: 'streetNumber')
  final String? streetNumber;
  @JsonKey(name: 'city')
  final String? city;
  @JsonKey(name: 'postalCode')
  final String? postalCode;
  static const fromJsonFactory = _$AddressFromJson;
  static const toJsonFactory = _$AddressToJson;
  Map<String, dynamic> toJson() => _$AddressToJson(this);

  @override
  bool operator ==(dynamic other) {
    return identical(this, other) ||
        (other is Address &&
            (identical(other.geolocation, geolocation) ||
                const DeepCollectionEquality()
                    .equals(other.geolocation, geolocation)) &&
            (identical(other.country, country) ||
                const DeepCollectionEquality()
                    .equals(other.country, country)) &&
            (identical(other.street, street) ||
                const DeepCollectionEquality().equals(other.street, street)) &&
            (identical(other.streetNumber, streetNumber) ||
                const DeepCollectionEquality()
                    .equals(other.streetNumber, streetNumber)) &&
            (identical(other.city, city) ||
                const DeepCollectionEquality().equals(other.city, city)) &&
            (identical(other.postalCode, postalCode) ||
                const DeepCollectionEquality()
                    .equals(other.postalCode, postalCode)));
  }

  @override
  String toString() => jsonEncode(this);

  @override
  int get hashCode =>
      const DeepCollectionEquality().hash(geolocation) ^
      const DeepCollectionEquality().hash(country) ^
      const DeepCollectionEquality().hash(street) ^
      const DeepCollectionEquality().hash(streetNumber) ^
      const DeepCollectionEquality().hash(city) ^
      const DeepCollectionEquality().hash(postalCode) ^
      runtimeType.hashCode;
}

@JsonSerializable(explicitToJson: true)
class Geolocation {
  Geolocation({
    required this.latitude,
    required this.longitude,
  });

  factory Geolocation.fromJson(Map<String, dynamic> json) =>
      _$GeolocationFromJson(json);

  @JsonKey(name: 'latitude')
  final double? latitude;
  @JsonKey(name: 'longitude')
  final double? longitude;
  static const fromJsonFactory = _$GeolocationFromJson;
  static const toJsonFactory = _$GeolocationToJson;
  Map<String, dynamic> toJson() => _$GeolocationToJson(this);

  @override
  bool operator ==(dynamic other) {
    return identical(this, other) ||
        (other is Geolocation &&
            (identical(other.latitude, latitude) ||
                const DeepCollectionEquality()
                    .equals(other.latitude, latitude)) &&
            (identical(other.longitude, longitude) ||
                const DeepCollectionEquality()
                    .equals(other.longitude, longitude)));
  }

  @override
  String toString() => jsonEncode(this);

  @override
  int get hashCode =>
      const DeepCollectionEquality().hash(latitude) ^
      const DeepCollectionEquality().hash(longitude) ^
      runtimeType.hashCode;
}

Describe the solution you'd like
Nested schema objects in oneOf, anyOf, allOf, not arrays should be handled properly at least for a simple single-entry use case.

Library version used:
2.9.0

Swagger specification link
oneOf, anyOf, allOf, not

[Vovanella95]

Hi @Krawart , sorry for long fix. But it's done!