Disallow non-breakable chains of circular references in Input Objects (#701)

* Disallow non-breakable chains of circular references in Input Objects

* Editorial changes

* Editorial

Co-authored-by: Lee Byron <lee@leebyron.com>

Author: spawnia

spec/Section 3 -- Type System.md

@@ -1448,6 +1448,60 @@ define arguments or contain references to interfaces and unions, neither of
 which is appropriate for use as an input argument. For this reason, input
 objects have a separate type in the system.
 
+**Circular References**
+
+Input Objects are allowed to reference other Input Objects as field types. A 
+circular reference occurs when an Input Object references itself either directly 
+or through referenced Input Objects.
+
+Circular references are generally allowed, however they may not be defined as an
+unbroken chain of Non-Null singular fields. Such Input Objects are invalid 
+because there is no way to provide a legal value for them.
+
+This example of a circularly-referenced input type is valid as the field `self` 
+may be omitted or the value {null}.
+
+```graphql example
+input Example {
+  self: Example
+  value: String
+}
+```
+
+This example is also valid as the field `self` may be an empty List.
+
+```graphql example
+input Example {
+  self: [Example!]!
+  value: String
+}
+```
+
+This example of a circularly-referenced input type is invalid as the field 
+`self` cannot be provided a finite value.
+
+```graphql counter-example
+input Example {
+  value: String
+  self: Example!
+}
+```
+
+This example is also invalid, as there is a non-null singular circular reference 
+via the `First.second` and `Second.first` fields.
+
+```graphql counter-example
+input First {
+  second: Second!
+  value: String
+}
+
+input Second {
+  first: First!
+  value: String
+}
+```
+
 **Result Coercion**
 
 An input object is never a valid result. Input Object types cannot be the return
@@ -1526,6 +1580,9 @@ Literal Value            | Variables               | Coerced Value
       characters {"__"} (two underscores).
    3. The input field must accept a type where {IsInputType(inputFieldType)}
       returns {true}.
+3. If an Input Object references itself either directly or through referenced
+   Input Objects, at least one of the fields in the chain of references must be
+   either a nullable or a List type.
 
 
 ### Input Object Extensions