-- in.cue --
a1: {
    f: [f]
}

a2: {
    f: f
}

a3: {
    f: { g: f }
}

a4: {
    a: [a|int]
}

a5: {
    a: b: a | int
}

a6: {
    a: a | int
}

a7: {
    a: c.x
    b: {
        x: c
        y: "foo"
    }
    c: {
        x: b.y
        y: 3
    }
}

b1: {
    b: a & [1]
    a: [a|int]
}

b2: {
    a: [a|int]
    b: a & [1]
}

b3: {
    x: a: [a|int]
    b: x & {a: [1]}
}

b4: {
    b: x.y & [1]
    x: y: [y]
}

b5: {
    b: x.y & {a: [1]}
    x: y: a: [a|int]
}

b6: {
    b: x & {a: [1]}
    x: a: [a]
}

// TODO: erroneous: b should be an error. My suspicion is that `a` is detected
// as a reference cycle, because list don't introduce a new scope, allowing
// `1` to unify with the equivalent of `a: a` (which normally would be okay).
b7: {
    b: a & [[1]]
    a: [a]
}

// Issue #555
b8: {
    x: a
    a: f: b
    b: a | string
}

// Issue #555
b9: {
    #a: string | #b | #ref
    #b: {
      c: [#a, #a, #a]
    }
    #ref: ref: string
    x: #b | #ref
}

// Issue #534
b10: {
    a: close({
        b: string | a | c
    })
    c: close({
        d: string | a
    })
}

// Issue #509 -- with comprehension
b11: {
    #list: {
      tail: #list | *null
      if tail != null {
      }
    }
}

// Issue #509 -- with comprehension
b12: {
    #list: {
      V=value: int
      T=tail: #list|*null
      if T != null {
        sum: V + T.sum
      }
      if T == null {
        sum: V
      }
    }

    list1: #list
      list1: {
        value: 1,
        tail: {
          value: 2
          tail: {
          value: 3
          tail: {
            value: 4
          }
        }
      }
    }
}

// More trigger happy on stack overflows.
b12b: {
      #list: {
    tail: #list

      if tail != null {
        sum: tail.sum
      }
    }

    list1: #list
    list1: {
       tail: {
          tail: {
          }
       }
    }
}

// Issue #587
b13: root: a: [ for x in root {x} ]

// Issue #587
b14: {
  root: {
    a: [...int]

    for x in a {
      "\(x)": {}
    }

    b: [ for x in root {x}]
  }
}

// This is okay
// Issue #587
b15: root: a: { for x in root {x} }

// Issue #502 -- unused bulk constraints are not cyclic
p1: {
  #T: {
    a: [string]: link: #T
  }

  a: #T & {
    a: one: link: a: two: {}
  }
}

// Issue #502 -- but they are if it is invoked within the struct.
p2: {
  #T: {
    a: [string]: link: #T
    a: b: {}
  }

  a: #T & {
    a: one: link: a: two: {}
  }
}

// Issue #502 -- or added later.
p3: {
  #S: #T: {
    a: [string]: link: #T
  }

  #U: {
    #S
    #T: a: b: {}
  }

  a: #U.#T & {
    a: one: link: a: two: {}
  }
}

// Issue #502 -- unused bulk constraints are not cyclic
p4: {
  #T: {
    a: [...{link: #T}]
  }

  a: #T & {
    a: [{link: a: [{}]}]
  }
}

// Issue #502 -- but they are if it is invoked within the struct.
p5: {
  #T: {
    a: [...{link: #T}]
    a: [{}]
  }

  a: #T & {
    a: [{link: a: [{}]}]
  }
}

// Issue #502 -- or added later.
p6: {
  #S: #T: {
    a: [...{link: #T}]
  }

  #U: {
    #S
    #T: a: [{}]
  }

  a: #U.#T & {
    a: [{link: a: [{}]}]
  }
}


c1: {
  a: {
    b: {}
    c: a & b
  }
}

// indirection
d1: {
    a: b: c: d: { h: int, t: r }
    r: a.b

    x: a.b.c
}

d2: {
    x: a.b.c

    r: a.b
    a: b: c: d: { h: int, t: r }
}

d3: {
    // TODO(errors): correct position reporting in structural cycle.
    config: {
        a: b: c: indirect
        indirect: [a.b, null][i]
        i: int | *1
    }
    x: config & { i: 0 }
}


// combining structural with reference cycles
e1: {
    a: a
    a: c: a

    b: c: b
    b: b
}

e2: {
    a: {a}
    a: c: a

    b: c: b
    b: {b}
}

e3: {
    a: [a]
    a: c: a

    b: [b]
    b: c: b
}

e4: {
    a: [a | {}]
    a: [[{c: 1}]]

    b: [[{c: 1}]]
    b: [b | {}]
}


e5: {
    a: c: a | int
    a: a | int

    b: b | int
    b: c: b | int
}


// validating values
v1: {
    x: [x | int, 1]
    y: x & [[[2], 1], 1]
}

v2: {
    y: x & [[[2], 1], 1]
    x: [x | int, 1]
}

v3: {
    list: {
        head: int
        tail: list | null
    }

    myList: list
    myList: {
        head: 2
        tail: {
            head: 3
            tail: {
                head: 4
            }
        }
    }
}

v4: {
    list: {
        head: int
        tail: list | 1
    }

    myList: list
    myList: {
        head: 2
        tail: head: 3
    }
}

v5: {
    list: {
        head: int
        tail: list | {}
    }

    myList: list
    myList: {
        head: 2
        tail: head: 3
    }
}


// Example from "The Logic of Type Feature Structures" (Bob Carpenter)/
z1: {
    y: {
        f: h: g
        g: _
    }
    x: {
        f: _
        g: f
    }
    z: x & y
}


// Ensure these are NOT treated as structural errors.

n1: a: b: int
n2: n1 & { a: n1 }
n3: n1 & { n1 }
n4: n1 & { x: n1 & { y: n1 & { z: int }}}


-- out/eval --
Errors:
a1.f.0: structural cycle
a3.f.g: structural cycle
b12b.#list.tail.tail: structural cycle
b13.root.a.0.0: structural cycle
b14.root.b.1.1: structural cycle
b4.x.y.0: structural cycle
b6.b.a.0: conflicting values 1 and [1] (mismatched types int and list):
    ./in.cue:63:8
    ./in.cue:63:16
    ./in.cue:63:17
    ./in.cue:64:12
b6.b.a.0.0: structural cycle
b6.x.a.0: structural cycle
b7.a.0: structural cycle
c1.a.c.c: structural cycle
d1.a.b.c.d.t: structural cycle
d1.r: structural cycle
d2.r.c.d.t: structural cycle
d2.x.d.t.c.d.t: structural cycle
e1.a.c: structural cycle
e1.b.c: structural cycle
e2.a.c: structural cycle
e2.b.c: structural cycle
e3.a: conflicting values [a] and {c:a} (mismatched types list and struct):
    ./in.cue:308:8
    ./in.cue:309:8
e3.a.0: conflicting values [a] and {c:a} (mismatched types list and struct):
    ./in.cue:308:8
    ./in.cue:308:9
    ./in.cue:309:8
e3.a.0: structural cycle
e3.a.c: conflicting values [a] and {c:a} (mismatched types list and struct):
    ./in.cue:308:8
    ./in.cue:309:8
    ./in.cue:309:11
e3.a.c: structural cycle
e3.b: conflicting values [b] and {c:b} (mismatched types list and struct):
    ./in.cue:311:8
    ./in.cue:312:8
e3.b.0: conflicting values [b] and {c:b} (mismatched types list and struct):
    ./in.cue:311:8
    ./in.cue:311:9
    ./in.cue:312:8
e3.b.0: structural cycle
e3.b.c: conflicting values [b] and {c:b} (mismatched types list and struct):
    ./in.cue:311:8
    ./in.cue:312:8
    ./in.cue:312:11
e3.b.c: structural cycle
e4.a.0: 4 errors in empty disjunction:
e4.a.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
    ./in.cue:316:13
    ./in.cue:317:9
e4.a.0.0: 2 errors in empty disjunction:
e4.a.0.0: conflicting values [{c:1}] and {c:1} (mismatched types list and struct):
    ./in.cue:317:9
    ./in.cue:317:10
e4.a.0.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
    ./in.cue:316:9
    ./in.cue:316:13
    ./in.cue:317:9
e4.b.0: 4 errors in empty disjunction:
e4.b.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
    ./in.cue:319:9
    ./in.cue:320:13
e4.b.0.0: 2 errors in empty disjunction:
e4.b.0.0: conflicting values [{c:1}] and {c:1} (mismatched types list and struct):
    ./in.cue:319:9
    ./in.cue:319:10
e4.b.0.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
    ./in.cue:319:9
    ./in.cue:320:9
    ./in.cue:320:13
p2.#T.a.b.link: structural cycle
p3.#U.#T.a.b.link: structural cycle
p5.#T.a.0.link: structural cycle
p6.#U.#T.a.0.link: structural cycle
z1.z.f.h.h: structural cycle
z1.z.g.h: structural cycle
cycle error:
    ./in.cue:144:10
0: structural cycle:
    ./in.cue:283:19

Result:
(_|_){
  // [eval]
  a1: (_|_){
    // [structural cycle]
    f: (_|_){
      // [structural cycle]
      0: (_|_){
        // [structural cycle] a1.f.0: structural cycle
      }
    }
  }
  a2: (struct){
    f: (_){ _ }
  }
  a3: (_|_){
    // [structural cycle]
    f: (_|_){
      // [structural cycle]
      g: (_|_){
        // [structural cycle] a3.f.g: structural cycle
      }
    }
  }
  a4: (struct){
    a: (#list){
      0: (int){ int }
    }
  }
  a5: (struct){
    a: (struct){
      b: (int){ int }
    }
  }
  a6: (struct){
    a: (_){ |((_){ _ }, (int){ int }) }
  }
  a7: (struct){
    a: (string){ "foo" }
    b: (struct){
      x: (struct){
        x: (string){ "foo" }
        y: (int){ 3 }
      }
      y: (string){ "foo" }
    }
    c: (struct){
      x: (string){ "foo" }
      y: (int){ 3 }
    }
  }
  b1: (struct){
    b: (#list){
      0: (int){ 1 }
    }
    a: (#list){
      0: (int){ int }
    }
  }
  b2: (struct){
    a: (#list){
      0: (int){ int }
    }
    b: (#list){
      0: (int){ 1 }
    }
  }
  b3: (struct){
    x: (struct){
      a: (#list){
        0: (int){ int }
      }
    }
    b: (struct){
      a: (#list){
        0: (int){ 1 }
      }
    }
  }
  b4: (_|_){
    // [structural cycle]
    b: (#list){
      0: (int){ 1 }
    }
    x: (_|_){
      // [structural cycle]
      y: (_|_){
        // [structural cycle]
        0: (_|_){
          // [structural cycle] b4.x.y.0: structural cycle
        }
      }
    }
  }
  b5: (struct){
    b: (struct){
      a: (#list){
        0: (int){ 1 }
      }
    }
    x: (struct){
      y: (struct){
        a: (#list){
          0: (int){ int }
        }
      }
    }
  }
  b6: (_|_){
    // [eval]
    b: (_|_){
      // [eval]
      a: (_|_){
        // [eval]
        0: (_|_){
          // [eval] b6.b.a.0: conflicting values 1 and [1] (mismatched types int and list):
          //     ./in.cue:63:8
          //     ./in.cue:63:16
          //     ./in.cue:63:17
          //     ./in.cue:64:12
          0: (_|_){
            // [structural cycle] b6.b.a.0.0: structural cycle
          }
        }
      }
    }
    x: (_|_){
      // [structural cycle]
      a: (_|_){
        // [structural cycle]
        0: (_|_){
          // [structural cycle] b6.x.a.0: structural cycle
        }
      }
    }
  }
  b7: (_|_){
    // [structural cycle]
    b: (#list){
      0: (#list){
        0: (int){ 1 }
      }
    }
    a: (_|_){
      // [structural cycle]
      0: (_|_){
        // [structural cycle] b7.a.0: structural cycle
      }
    }
  }
  b8: (struct){
    x: (struct){
      f: (string){ string }
    }
    a: (struct){
      f: (string){ string }
    }
    b: (string){ string }
  }
  b9: (struct){
    #a: ((string|struct)){ |((string){ string }, (#struct){
        ref: (string){ string }
      }) }
    #b: (#struct){
      c: (#list){
        0: ((string|struct)){ |((string){ string }, (#struct){
            ref: (string){ string }
          }) }
        1: ((string|struct)){ |((string){ string }, (#struct){
            ref: (string){ string }
          }) }
        2: ((string|struct)){ |((string){ string }, (#struct){
            ref: (string){ string }
          }) }
      }
    }
    #ref: (#struct){
      ref: (string){ string }
    }
    x: (struct){ |((#struct){
        c: (#list){
          0: ((string|struct)){ |((string){ string }, (#struct){
              ref: (string){ string }
            }) }
          1: ((string|struct)){ |((string){ string }, (#struct){
              ref: (string){ string }
            }) }
          2: ((string|struct)){ |((string){ string }, (#struct){
              ref: (string){ string }
            }) }
        }
      }, (#struct){
        ref: (string){ string }
      }) }
  }
  b10: (struct){
    a: (#struct){
      b: ((string|struct)){ |((string){ string }, (#struct){
          d: (string){ string }
        }) }
    }
    c: (#struct){
      d: ((string|struct)){ |((string){ string }, (#struct){
          b: (string){ string }
        }) }
    }
  }
  b11: (struct){
    #list: (#struct){
      tail: ((null|struct)){ |(*(null){ null }, (#struct){
          tail: (null){ null }
        }) }
    }
  }
  b12: (struct){
    #list: (#struct){
      value: (int){ int }
      tail: ((null|struct)){ |(*(null){ null }, (#struct){
          value: (int){ int }
          tail: (null){ null }
          sum: (int){ int }
        }) }
      sum: (int){ int }
    }
    list1: (#struct){
      value: (int){ 1 }
      tail: (#struct){
        value: (int){ 2 }
        tail: (#struct){
          value: (int){ 3 }
          tail: (#struct){
            value: (int){ 4 }
            tail: (null){ null }
            sum: (int){ 4 }
          }
          sum: (int){ 7 }
        }
        sum: (int){ 9 }
      }
      sum: (int){ 10 }
    }
  }
  b12b: (_|_){
    // [structural cycle]
    #list: (_|_){
      // [structural cycle] cycle error:
      //     ./in.cue:144:10
      tail: (_|_){
        // [structural cycle] cycle error:
        //     ./in.cue:144:10
        tail: (_|_){
          // [structural cycle] b12b.#list.tail.tail: structural cycle
        }
      }
    }
    list1: (_|_){
      // [structural cycle] cycle error:
      //     ./in.cue:144:10
      tail: (struct){
        tail: (struct){
        }
      }
    }
  }
  b13: (_|_){
    // [structural cycle]
    root: (_|_){
      // [structural cycle]
      a: (_|_){
        // [structural cycle]
        0: (_|_){
          // [structural cycle]
          0: (_|_){
            // [structural cycle] b13.root.a.0.0: structural cycle
          }
        }
      }
    }
  }
  b14: (_|_){
    // [structural cycle]
    root: (_|_){
      // [structural cycle]
      a: (list){
      }
      b: (_|_){
        // [structural cycle]
        0: (list){
        }
        1: (_|_){
          // [structural cycle]
          0: (list){
          }
          1: (_|_){
            // [structural cycle] b14.root.b.1.1: structural cycle
          }
        }
      }
    }
  }
  b15: (struct){
    root: (struct){
      a: (struct){
      }
    }
  }
  p1: (struct){
    #T: (#struct){
      a: (#struct){
      }
    }
    a: (#struct){
      a: (#struct){
        one: (#struct){
          link: (#struct){
            a: (#struct){
              two: (#struct){
                link: (#struct){
                  a: (#struct){
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  p2: (_|_){
    // [structural cycle]
    #T: (_|_){
      // [structural cycle]
      a: (_|_){
        // [structural cycle]
        b: (_|_){
          // [structural cycle]
          link: (_|_){
            // [structural cycle] p2.#T.a.b.link: structural cycle
          }
        }
      }
    }
    a: (_|_){
      // [structural cycle]
      a: (struct){
        one: (struct){
          link: (struct){
            a: (struct){
              two: (struct){
              }
            }
          }
        }
      }
    }
  }
  p3: (_|_){
    // [structural cycle]
    #S: (#struct){
      #T: (#struct){
        a: (#struct){
        }
      }
    }
    #U: (_|_){
      // [structural cycle]
      #T: (_|_){
        // [structural cycle]
        a: (_|_){
          // [structural cycle]
          b: (_|_){
            // [structural cycle]
            link: (_|_){
              // [structural cycle] p3.#U.#T.a.b.link: structural cycle
            }
          }
        }
      }
    }
    a: (_|_){
      // [structural cycle] p3.#U.#T.a.b.link: structural cycle
      a: (struct){
        one: (struct){
          link: (struct){
            a: (struct){
              two: (struct){
              }
            }
          }
        }
      }
    }
  }
  p4: (struct){
    #T: (#struct){
      a: (list){
      }
    }
    a: (#struct){
      a: (#list){
        0: (#struct){
          link: (#struct){
            a: (#list){
              0: (#struct){
                link: (#struct){
                  a: (list){
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  p5: (_|_){
    // [structural cycle]
    #T: (_|_){
      // [structural cycle]
      a: (_|_){
        // [structural cycle]
        0: (_|_){
          // [structural cycle]
          link: (_|_){
            // [structural cycle] p5.#T.a.0.link: structural cycle
          }
        }
      }
    }
    a: (_|_){
      // [structural cycle]
      a: (#list){
        0: (struct){
          link: (struct){
            a: (#list){
              0: (struct){
              }
            }
          }
        }
      }
    }
  }
  p6: (_|_){
    // [structural cycle]
    #S: (#struct){
      #T: (#struct){
        a: (list){
        }
      }
    }
    #U: (_|_){
      // [structural cycle]
      #T: (_|_){
        // [structural cycle]
        a: (_|_){
          // [structural cycle]
          0: (_|_){
            // [structural cycle]
            link: (_|_){
              // [structural cycle] p6.#U.#T.a.0.link: structural cycle
            }
          }
        }
      }
    }
    a: (_|_){
      // [structural cycle] p6.#U.#T.a.0.link: structural cycle
      a: (#list){
        0: (struct){
          link: (struct){
            a: (#list){
              0: (struct){
              }
            }
          }
        }
      }
    }
  }
  c1: (_|_){
    // [structural cycle]
    a: (_|_){
      // [structural cycle]
      b: (struct){
      }
      c: (_|_){
        // [structural cycle]
        b: (struct){
        }
        c: (_|_){
          // [structural cycle] c1.a.c.c: structural cycle
        }
      }
    }
  }
  d1: (_|_){
    // [structural cycle]
    a: (_|_){
      // [structural cycle]
      b: (_|_){
        // [structural cycle]
        c: (_|_){
          // [structural cycle]
          d: (_|_){
            // [structural cycle]
            h: (int){ int }
            t: (_|_){
              // [structural cycle] d1.a.b.c.d.t: structural cycle
            }
          }
        }
      }
    }
    r: (_|_){
      // [structural cycle] d1.r: structural cycle
    }
    x: (_|_){
      // [structural cycle] d1.a.b.c.d.t: structural cycle
    }
  }
  d2: (_|_){
    // [structural cycle]
    x: (_|_){
      // [structural cycle]
      d: (_|_){
        // [structural cycle]
        h: (int){ int }
        t: (_|_){
          // [structural cycle]
          c: (_|_){
            // [structural cycle]
            d: (_|_){
              // [structural cycle]
              h: (int){ int }
              t: (_|_){
                // [structural cycle] d2.x.d.t.c.d.t: structural cycle
              }
            }
          }
        }
      }
    }
    r: (_|_){
      // [structural cycle]
      c: (_|_){
        // [structural cycle]
        d: (_|_){
          // [structural cycle]
          h: (int){ int }
          t: (_|_){
            // [structural cycle] d2.r.c.d.t: structural cycle
          }
        }
      }
    }
    a: (_|_){
      // [structural cycle]
      b: (_|_){
        // [structural cycle]
        c: (_|_){
          // [structural cycle]
          d: (_|_){
            // [structural cycle]
            h: (int){ int }
            t: (_|_){
              // [structural cycle]
            }
          }
        }
      }
    }
  }
  d3: (_|_){
    // [structural cycle]
    config: (_|_){
      // [structural cycle]
      a: (_|_){
        // [structural cycle]
        b: (_|_){
          // [structural cycle]
          c: (_|_){
            // [structural cycle] 0: structural cycle:
            //     ./in.cue:283:19
          }
        }
      }
      indirect: (_|_){
        // [structural cycle] 0: structural cycle:
        //     ./in.cue:283:19
      }
      i: (int){ |(*(int){ 1 }, (int){ int }) }
    }
    x: (_|_){
      // [structural cycle] 0: structural cycle:
      //     ./in.cue:283:19
      i: (int){ 0 }
    }
  }
  e1: (_|_){
    // [structural cycle]
    a: (_|_){
      // [structural cycle]
      c: (_|_){
        // [structural cycle] e1.a.c: structural cycle
      }
    }
    b: (_|_){
      // [structural cycle]
      c: (_|_){
        // [structural cycle] e1.b.c: structural cycle
      }
    }
  }
  e2: (_|_){
    // [structural cycle]
    a: (_|_){
      // [structural cycle]
      c: (_|_){
        // [structural cycle] e2.a.c: structural cycle
      }
    }
    b: (_|_){
      // [structural cycle]
      c: (_|_){
        // [structural cycle] e2.b.c: structural cycle
      }
    }
  }
  e3: (_|_){
    // [eval]
    a: (_|_){
      // [eval] e3.a: conflicting values [a] and {c:a} (mismatched types list and struct):
      //     ./in.cue:308:8
      //     ./in.cue:309:8
      c: (_|_){
        // [eval] e3.a.c: conflicting values [a] and {c:a} (mismatched types list and struct):
        //     ./in.cue:308:8
        //     ./in.cue:309:8
        //     ./in.cue:309:11
        // e3.a.c: structural cycle
      }
      0: (_|_){
        // [eval] e3.a.0: conflicting values [a] and {c:a} (mismatched types list and struct):
        //     ./in.cue:308:8
        //     ./in.cue:308:9
        //     ./in.cue:309:8
        // e3.a.0: structural cycle
      }
    }
    b: (_|_){
      // [eval] e3.b: conflicting values [b] and {c:b} (mismatched types list and struct):
      //     ./in.cue:311:8
      //     ./in.cue:312:8
      c: (_|_){
        // [eval] e3.b.c: conflicting values [b] and {c:b} (mismatched types list and struct):
        //     ./in.cue:311:8
        //     ./in.cue:312:8
        //     ./in.cue:312:11
        // e3.b.c: structural cycle
      }
      0: (_|_){
        // [eval] e3.b.0: conflicting values [b] and {c:b} (mismatched types list and struct):
        //     ./in.cue:311:8
        //     ./in.cue:311:9
        //     ./in.cue:312:8
        // e3.b.0: structural cycle
      }
    }
  }
  e4: (_|_){
    // [eval]
    a: (_|_){
      // [eval]
      0: (_|_){
        // [eval] e4.a.0: 4 errors in empty disjunction:
        // e4.a.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
        //     ./in.cue:316:13
        //     ./in.cue:317:9
        // e4.a.0.0: 2 errors in empty disjunction:
        // e4.a.0.0: conflicting values [{c:1}] and {c:1} (mismatched types list and struct):
        //     ./in.cue:317:9
        //     ./in.cue:317:10
        // e4.a.0.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
        //     ./in.cue:316:9
        //     ./in.cue:316:13
        //     ./in.cue:317:9
        0: (struct){
          c: (int){ 1 }
        }
      }
    }
    b: (_|_){
      // [eval]
      0: (_|_){
        // [eval] e4.b.0: 4 errors in empty disjunction:
        // e4.b.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
        //     ./in.cue:319:9
        //     ./in.cue:320:13
        // e4.b.0.0: 2 errors in empty disjunction:
        // e4.b.0.0: conflicting values [{c:1}] and {c:1} (mismatched types list and struct):
        //     ./in.cue:319:9
        //     ./in.cue:319:10
        // e4.b.0.0: conflicting values [{c:1}] and {} (mismatched types list and struct):
        //     ./in.cue:319:9
        //     ./in.cue:320:9
        //     ./in.cue:320:13
        0: (struct){
          c: (int){ 1 }
        }
      }
    }
  }
  e5: (struct){
    a: (struct){
      c: (int){ int }
    }
    b: (struct){
      c: (int){ int }
    }
  }
  v1: (struct){
    x: (#list){
      0: (int){ int }
      1: (int){ 1 }
    }
    y: (#list){
      0: (#list){
        0: (#list){
          0: (int){ 2 }
        }
        1: (int){ 1 }
      }
      1: (int){ 1 }
    }
  }
  v2: (struct){
    y: (#list){
      0: (#list){
        0: (#list){
          0: (int){ 2 }
        }
        1: (int){ 1 }
      }
      1: (int){ 1 }
    }
    x: (#list){
      0: (int){ int }
      1: (int){ 1 }
    }
  }
  v3: (struct){
    list: (struct){
      head: (int){ int }
      tail: (null){ null }
    }
    myList: (struct){
      head: (int){ 2 }
      tail: (struct){
        head: (int){ 3 }
        tail: (struct){
          head: (int){ 4 }
          tail: (null){ null }
        }
      }
    }
  }
  v4: (struct){
    list: (struct){
      head: (int){ int }
      tail: (int){ 1 }
    }
    myList: (struct){
      head: (int){ 2 }
      tail: (struct){
        head: (int){ 3 }
        tail: (int){ 1 }
      }
    }
  }
  v5: (struct){
    list: (struct){
      head: (int){ int }
      tail: (struct){
      }
    }
    myList: (struct){
      head: (int){ 2 }
      tail: (struct){ |((struct){
          head: (int){ 3 }
          tail: (struct){
          }
        }, (struct){
          head: (int){ 3 }
        }) }
    }
  }
  z1: (_|_){
    // [structural cycle]
    y: (struct){
      f: (struct){
        h: (_){ _ }
      }
      g: (_){ _ }
    }
    x: (struct){
      f: (_){ _ }
      g: (_){ _ }
    }
    z: (_|_){
      // [structural cycle]
      f: (_|_){
        // [structural cycle]
        h: (_|_){
          // [structural cycle]
          h: (_|_){
            // [structural cycle] z1.z.f.h.h: structural cycle
          }
        }
      }
      g: (_|_){
        // [structural cycle]
        h: (_|_){
          // [structural cycle] z1.z.g.h: structural cycle
        }
      }
    }
  }
  n1: (struct){
    a: (struct){
      b: (int){ int }
    }
  }
  n2: (struct){
    a: (struct){
      b: (int){ int }
      a: (struct){
        b: (int){ int }
      }
    }
  }
  n3: (struct){
    a: (struct){
      b: (int){ int }
    }
  }
  n4: (struct){
    a: (struct){
      b: (int){ int }
    }
    x: (struct){
      a: (struct){
        b: (int){ int }
      }
      y: (struct){
        a: (struct){
          b: (int){ int }
        }
        z: (int){ int }
      }
    }
  }
}
-- out/compile --
--- in.cue
{
  a1: {
    f: [
      〈0;f〉,
    ]
  }
  a2: {
    f: 〈0;f〉
  }
  a3: {
    f: {
      g: 〈1;f〉
    }
  }
  a4: {
    a: [
      (〈0;a〉|int),
    ]
  }
  a5: {
    a: {
      b: (〈1;a〉|int)
    }
  }
  a6: {
    a: (〈0;a〉|int)
  }
  a7: {
    a: 〈0;c〉.x
    b: {
      x: 〈1;c〉
      y: "foo"
    }
    c: {
      x: 〈1;b〉.y
      y: 3
    }
  }
  b1: {
    b: (〈0;a〉 & [
      1,
    ])
    a: [
      (〈0;a〉|int),
    ]
  }
  b2: {
    a: [
      (〈0;a〉|int),
    ]
    b: (〈0;a〉 & [
      1,
    ])
  }
  b3: {
    x: {
      a: [
        (〈0;a〉|int),
      ]
    }
    b: (〈0;x〉 & {
      a: [
        1,
      ]
    })
  }
  b4: {
    b: (〈0;x〉.y & [
      1,
    ])
    x: {
      y: [
        〈0;y〉,
      ]
    }
  }
  b5: {
    b: (〈0;x〉.y & {
      a: [
        1,
      ]
    })
    x: {
      y: {
        a: [
          (〈0;a〉|int),
        ]
      }
    }
  }
  b6: {
    b: (〈0;x〉 & {
      a: [
        1,
      ]
    })
    x: {
      a: [
        〈0;a〉,
      ]
    }
  }
  b7: {
    b: (〈0;a〉 & [
      [
        1,
      ],
    ])
    a: [
      〈0;a〉,
    ]
  }
  b8: {
    x: 〈0;a〉
    a: {
      f: 〈1;b〉
    }
    b: (〈0;a〉|string)
  }
  b9: {
    #a: (string|〈0;#b〉|〈0;#ref〉)
    #b: {
      c: [
        〈1;#a〉,
        〈1;#a〉,
        〈1;#a〉,
      ]
    }
    #ref: {
      ref: string
    }
    x: (〈0;#b〉|〈0;#ref〉)
  }
  b10: {
    a: close({
      b: (string|〈1;a〉|〈1;c〉)
    })
    c: close({
      d: (string|〈1;a〉)
    })
  }
  b11: {
    #list: {
      tail: (〈1;#list〉|*null)
      if (〈0;tail〉 != null) {}
    }
  }
  b12: {
    #list: {
      value: int
      tail: (〈1;#list〉|*null)
      if (〈0;tail〉 != null) {
        sum: (〈1;value〉 + 〈1;tail〉.sum)
      }
      if (〈0;tail〉 == null) {
        sum: 〈1;value〉
      }
    }
    list1: 〈0;#list〉
    list1: {
      value: 1
      tail: {
        value: 2
        tail: {
          value: 3
          tail: {
            value: 4
          }
        }
      }
    }
  }
  b12b: {
    #list: {
      tail: 〈1;#list〉
      if (〈0;tail〉 != null) {
        sum: 〈1;tail〉.sum
      }
    }
    list1: 〈0;#list〉
    list1: {
      tail: {
        tail: {}
      }
    }
  }
  b13: {
    root: {
      a: [
        for _, x in 〈1;root〉 {
          〈1;x〉
        },
      ]
    }
  }
  b14: {
    root: {
      a: [
        ...int,
      ]
      for _, x in 〈0;a〉 {
        "\(〈1;x〉)": {}
      }
      b: [
        for _, x in 〈1;root〉 {
          〈1;x〉
        },
      ]
    }
  }
  b15: {
    root: {
      a: {
        for _, x in 〈2;root〉 {
          〈1;x〉
        }
      }
    }
  }
  p1: {
    #T: {
      a: {
        [string]: {
          link: 〈3;#T〉
        }
      }
    }
    a: (〈0;#T〉 & {
      a: {
        one: {
          link: {
            a: {
              two: {}
            }
          }
        }
      }
    })
  }
  p2: {
    #T: {
      a: {
        [string]: {
          link: 〈3;#T〉
        }
      }
      a: {
        b: {}
      }
    }
    a: (〈0;#T〉 & {
      a: {
        one: {
          link: {
            a: {
              two: {}
            }
          }
        }
      }
    })
  }
  p3: {
    #S: {
      #T: {
        a: {
          [string]: {
            link: 〈3;#T〉
          }
        }
      }
    }
    #U: {
      〈1;#S〉
      #T: {
        a: {
          b: {}
        }
      }
    }
    a: (〈0;#U〉.#T & {
      a: {
        one: {
          link: {
            a: {
              two: {}
            }
          }
        }
      }
    })
  }
  p4: {
    #T: {
      a: [
        ...{
          link: 〈2;#T〉
        },
      ]
    }
    a: (〈0;#T〉 & {
      a: [
        {
          link: {
            a: [
              {},
            ]
          }
        },
      ]
    })
  }
  p5: {
    #T: {
      a: [
        ...{
          link: 〈2;#T〉
        },
      ]
      a: [
        {},
      ]
    }
    a: (〈0;#T〉 & {
      a: [
        {
          link: {
            a: [
              {},
            ]
          }
        },
      ]
    })
  }
  p6: {
    #S: {
      #T: {
        a: [
          ...{
            link: 〈2;#T〉
          },
        ]
      }
    }
    #U: {
      〈1;#S〉
      #T: {
        a: [
          {},
        ]
      }
    }
    a: (〈0;#U〉.#T & {
      a: [
        {
          link: {
            a: [
              {},
            ]
          }
        },
      ]
    })
  }
  c1: {
    a: {
      b: {}
      c: (〈1;a〉 & 〈0;b〉)
    }
  }
  d1: {
    a: {
      b: {
        c: {
          d: {
            h: int
            t: 〈4;r〉
          }
        }
      }
    }
    r: 〈0;a〉.b
    x: 〈0;a〉.b.c
  }
  d2: {
    x: 〈0;a〉.b.c
    r: 〈0;a〉.b
    a: {
      b: {
        c: {
          d: {
            h: int
            t: 〈4;r〉
          }
        }
      }
    }
  }
  d3: {
    config: {
      a: {
        b: {
          c: 〈2;indirect〉
        }
      }
      indirect: [
        〈0;a〉.b,
        null,
      ][〈0;i〉]
      i: (int|*1)
    }
    x: (〈0;config〉 & {
      i: 0
    })
  }
  e1: {
    a: 〈0;a〉
    a: {
      c: 〈1;a〉
    }
    b: {
      c: 〈1;b〉
    }
    b: 〈0;b〉
  }
  e2: {
    a: {
      〈1;a〉
    }
    a: {
      c: 〈1;a〉
    }
    b: {
      c: 〈1;b〉
    }
    b: {
      〈1;b〉
    }
  }
  e3: {
    a: [
      〈0;a〉,
    ]
    a: {
      c: 〈1;a〉
    }
    b: [
      〈0;b〉,
    ]
    b: {
      c: 〈1;b〉
    }
  }
  e4: {
    a: [
      (〈0;a〉|{}),
    ]
    a: [
      [
        {
          c: 1
        },
      ],
    ]
    b: [
      [
        {
          c: 1
        },
      ],
    ]
    b: [
      (〈0;b〉|{}),
    ]
  }
  e5: {
    a: {
      c: (〈1;a〉|int)
    }
    a: (〈0;a〉|int)
    b: (〈0;b〉|int)
    b: {
      c: (〈1;b〉|int)
    }
  }
  v1: {
    x: [
      (〈0;x〉|int),
      1,
    ]
    y: (〈0;x〉 & [
      [
        [
          2,
        ],
        1,
      ],
      1,
    ])
  }
  v2: {
    y: (〈0;x〉 & [
      [
        [
          2,
        ],
        1,
      ],
      1,
    ])
    x: [
      (〈0;x〉|int),
      1,
    ]
  }
  v3: {
    list: {
      head: int
      tail: (〈1;list〉|null)
    }
    myList: 〈0;list〉
    myList: {
      head: 2
      tail: {
        head: 3
        tail: {
          head: 4
        }
      }
    }
  }
  v4: {
    list: {
      head: int
      tail: (〈1;list〉|1)
    }
    myList: 〈0;list〉
    myList: {
      head: 2
      tail: {
        head: 3
      }
    }
  }
  v5: {
    list: {
      head: int
      tail: (〈1;list〉|{})
    }
    myList: 〈0;list〉
    myList: {
      head: 2
      tail: {
        head: 3
      }
    }
  }
  z1: {
    y: {
      f: {
        h: 〈1;g〉
      }
      g: _
    }
    x: {
      f: _
      g: 〈0;f〉
    }
    z: (〈0;x〉 & 〈0;y〉)
  }
  n1: {
    a: {
      b: int
    }
  }
  n2: (〈0;n1〉 & {
    a: 〈1;n1〉
  })
  n3: (〈0;n1〉 & {
    〈1;n1〉
  })
  n4: (〈0;n1〉 & {
    x: (〈1;n1〉 & {
      y: (〈2;n1〉 & {
        z: int
      })
    })
  })
}