Circular references in Definitions Object

Syntactically, it seems possible to construct an infinite circular reference using Definitions Objects.

Obviously, such a reference could never actually be called or returned. I can’t find any conclusive answer on this in the specs. The editor at http://editor.swagger.io/ seems to accept it as valid syntax, but produces an undefined Schema.

How should such a situation be treated?

Example

{
    "swagger": "2.0",
    "info": {
        "title": "vanderlee/PHPSwaggerGen",
        "version": "2.3.7"
    },
    "host": "example.com",
    "basePath": "\/base",
    "paths": {
        "\/customers": {
            "get": {
                "tags": [
                    "Test"
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#\/definitions\/Person"
                        }
                    }
                }
            }
        }
    },
    "definitions": {
        "Address": {
            "type": "object",
            "required": [
                "city",             
        "occupant"
            ],
            "properties": {
                "city": {
                    "type": "string"
                },
                "occupant": {
                    "$ref": "#\/definitions\/Person"
                }
            }
        },
        "Person": {
            "type": "object",
            "required": [
                "name",
                "home"
            ],
            "properties": {
                "name": {
                    "type": "string"
                },
                "home": {
                    "$ref": "#\/definitions\/Address"
                }
            }
        }
    },
    "tags": [
        {
            "name": "Test"
        }
    ]
}

[tedepstein]

Just read through this, and I think a few points are worth adding, or reiterating:

• Circular references in the schemas do not necessarily imply circular references in the data. It’s possible for Person to have properties like spouse, children, or parents that also refer to Person, but will never realistically form a cycle in an actual message.
• Where two or more references form a cycle, making each of those references required does indeed make the schema unsatisfiable. There is no finite message that could possibly conform to the schema. This is just one of many ways to create an unsatisfiable schema. Some of these conditions are potentially easy to detect, but others (like conflicting regular expressions in pattern constraints) are a lot harder to prove satisfiable or not. I suspect this is why JSON Schema (and therefore OpenAPI) decided to leave it up to users.
• What’s being called “ambiguity” in the OpenAPI and/or JSON Schema specification is not really ambiguity. It’s a partitioning of responsibilities, leaving it up to the user to ensure that schemas are satisfiable and logically consistent. Of course, tools can try to detect and flag logical inconsistencies. The specification doesn’t require tools to do this, but it doesn’t preclude it.

[loganfreeman]

It is sad that circular reference could result in Java heap space error.