github.com/solo-io/cue@v0.4.7/cue/testdata/disjunctions/elimination.txtar

// Ensure that disjunction elimination is not done prematurely.

// Issue #651

-- in.cue --
import "struct"

// Closedness checks should not be triggered too early, or with an improper
// subset of StructInfos. Blindly finalizing partial disjuncts will end up
// doing a closedness check with not all embeddings present, which can lead to
// a field being rejected prematurely.
//
// It should be recursively disabled.
disambiguateClosed: {
    b: #Def & a
    a: #Def
    #Def: { {x: true} | {y: true} }
}

// Checks should never be disabled for field matching.
alwaysCheckMatchers1: {
    b: {[=~"^xxxx$"]: int} | null
    b: {c:            string} | null
    b: c: "yyyyy"
}

alwaysCheckPatterns2: {
    a: #X
    a: b

    b: #X
    b: c: "yyyyy"

    #X: string | {
        c: string
        {[=~"^xxxx$"]: int}
    }
}

nestedNonMonotonic: resolved: n1: {
    x: { a: struct.MinFields(2) } | null
    x: { a: c: 1 } | null
    x: { a: d: 1 } | null
}

nestedNonMonotonic: resolved: n2: {
    x: { a: b: struct.MinFields(2) } | null
    x: { a: b: c: 1 } | null
    x: { a: b: d: 1 } | null
}

nestedNonMonotonic: eliminated: n1: p1: {
    x: { a: struct.MaxFields(1) } | null
    x: { a: c: 1 } | null
    x: { a: d: 1 } | null
}

nestedNonMonotonic: eliminated: n1: p2: {
    x: { a: c: 1 } | null
    x: { a: struct.MaxFields(1) } | null
    x: { a: d: 1 } | null
}

nestedNonMonotonic: eliminated: n1: p2: {
    x: { a: c: 1 } | null
    x: { a: d: 1 } | null
    x: { a: struct.MaxFields(1) } | null
}

nestedNonMonotonic: eliminated: n2: p1: {
    x: { a: b: struct.MaxFields(1) } | null
    x: { a: b: c: 1 } | null
    x: { a: b: d: 1 } | null
}

nestedNonMonotonic: eliminated: n2: p2: {
    x: { a: b: c: 1 } | null
    x: { a: b: struct.MaxFields(1) } | null
    x: { a: b: d: 1 } | null
}

nestedNonMonotonic: eliminated: n2: p2: {
    x: { a: b: c: 1 } | null
    x: { a: b: d: 1 } | null
    x: { a: b: struct.MaxFields(1) } | null
}

nestedNonMonotonic: incomplete: a: n1: p1:  {
    x: { a: struct.MinFields(2) } | null
    x: { a: c: 1 } | null
}

nestedNonMonotonic: incomplete: a: n1: p2:  {
    x: { a: c: 1 } | null
    x: { a: struct.MinFields(2) } | null
}

nestedNonMonotonic: incomplete: a: n2: p1:  {
    x: { a: b: struct.MinFields(2) } | null
    x: { a: b: c: 1 } | null
}

nestedNonMonotonic: incomplete: a: n2: p2:  {
    x: { a: b: c: 1 } | null
    x: { a: b: struct.MinFields(2) } | null
}


nestedNonMonotonic: incomplete: b: n1: p1: {
    x: { a: struct.MinFields(3) } | null
    x: { a: c: 1 } | null
    x: { a: d: 1 } | null
}

nestedNonMonotonic: incomplete: b: n1: p2: {
    x: { a: c: 1 } | null
    x: { a: struct.MinFields(3) } | null
    x: { a: d: 1 } | null
}

nestedNonMonotonic: incomplete: b: n1: p3: {
    x: { a: c: 1 } | null
    x: { a: d: 1 } | null
    x: { a: struct.MinFields(3) } | null
}

nestedNonMonotonic: incomplete: b: n2: p1: {
    x: { a: b: struct.MinFields(3) } | null
    x: { a: b: c: 1 } | null
    x: { a: b: d: 1 } | null
}

nestedNonMonotonic: incomplete: b: n2: p1: {
    x: { a: b: c: 1 } | null
    x: { a: b: struct.MinFields(3) } | null
    x: { a: b: d: 1 } | null
}

nestedNonMonotonic: incomplete: b: n2: p1: {
    x: { a: b: c: 1 } | null
    x: { a: b: d: 1 } | null
    x: { a: b: struct.MinFields(3) } | null
}

preserveClosedness: small: p1: {
    #A: #B & {a: string}
    #B: {
      *{} | {a: string}
      *{} | {b: int}
    }
}

preserveClosedness: small: p2: {
    #A: #B & {a: string}
    #B: {
      {a: string} | *{}
      *{} | {b: int}
    }
}

preserveClosedness: medium: p1: {
    #A: #B & {a: string}
    #B: {
      *{} | {a: string} | {b: string}
      *{} | {c: int} | {d: string}
    }
}

preserveClosedness: medium: p2: {
    #A: #B & {a: string}
    #B: {
      {a: string} | *{} | {b: string}
      *{} | {c: int} | {d: string}
    }
}

preserveClosedness: medium: p3: {
    #A: #B & {a: string}
    #B: {
      {a: string} | {b: string} | *{}
      *{} | {c: int} | {d: string}
    }
}

-- out/eval --
(struct){
  disambiguateClosed: (struct){
    b: (#struct){ |((#struct){
        x: (bool){ true }
      }, (#struct){
        y: (bool){ true }
      }) }
    a: (#struct){ |((#struct){
        x: (bool){ true }
      }, (#struct){
        y: (bool){ true }
      }) }
    #Def: (#struct){ |((#struct){
        x: (bool){ true }
      }, (#struct){
        y: (bool){ true }
      }) }
  }
  alwaysCheckMatchers1: (struct){
    b: (struct){
      c: (string){ "yyyyy" }
    }
  }
  alwaysCheckPatterns2: (struct){
    a: (#struct){
      c: (string){ "yyyyy" }
    }
    b: (#struct){
      c: (string){ "yyyyy" }
    }
    #X: ((string|struct)){ |((string){ string }, (#struct){
        c: (string){ string }
      }) }
  }
  nestedNonMonotonic: (struct){
    resolved: (struct){
      n1: (struct){
        x: ((null|struct)){ |((struct){
            a: (struct){
              c: (int){ 1 }
              d: (int){ 1 }
            }
          }, (null){ null }) }
      }
      n2: (struct){
        x: ((null|struct)){ |((struct){
            a: (struct){
              b: (struct){
                c: (int){ 1 }
                d: (int){ 1 }
              }
            }
          }, (null){ null }) }
      }
    }
    eliminated: (struct){
      n1: (struct){
        p1: (struct){
          x: (null){ null }
        }
        p2: (struct){
          x: (null){ null }
        }
      }
      n2: (struct){
        p1: (struct){
          x: (null){ null }
        }
        p2: (struct){
          x: (null){ null }
        }
      }
    }
    incomplete: (struct){
      a: (struct){
        n1: (struct){
          p1: (struct){
            x: ((null|struct)){ |((struct){
                a: (_|_){
                  // [incomplete] nestedNonMonotonic.incomplete.a.n1.p1.x.a: invalid value {c:1} (does not satisfy struct.MinFields(2)): len(fields) < MinFields(2) (1 < 2):
                  //     ./in.cue:84:13
                  //     ./in.cue:84:10
                  //     ./in.cue:84:30
                  //     ./in.cue:85:10
                  c: (int){ 1 }
                }
              }, (null){ null }) }
          }
          p2: (struct){
            x: ((null|struct)){ |((struct){
                a: (_|_){
                  // [incomplete] nestedNonMonotonic.incomplete.a.n1.p2.x.a: invalid value {c:1} (does not satisfy struct.MinFields(2)): len(fields) < MinFields(2) (1 < 2):
                  //     ./in.cue:90:13
                  //     ./in.cue:89:10
                  //     ./in.cue:90:10
                  //     ./in.cue:90:30
                  c: (int){ 1 }
                }
              }, (null){ null }) }
          }
        }
        n2: (struct){
          p1: (struct){
            x: ((null|struct)){ |((struct){
                a: (struct){
                  b: (_|_){
                    // [incomplete] nestedNonMonotonic.incomplete.a.n2.p1.x.a.b: invalid value {c:1} (does not satisfy struct.MinFields(2)): len(fields) < MinFields(2) (1 < 2):
                    //     ./in.cue:94:16
                    //     ./in.cue:94:13
                    //     ./in.cue:94:33
                    //     ./in.cue:95:13
                    c: (int){ 1 }
                  }
                }
              }, (null){ null }) }
          }
          p2: (struct){
            x: ((null|struct)){ |((struct){
                a: (struct){
                  b: (_|_){
                    // [incomplete] nestedNonMonotonic.incomplete.a.n2.p2.x.a.b: invalid value {c:1} (does not satisfy struct.MinFields(2)): len(fields) < MinFields(2) (1 < 2):
                    //     ./in.cue:100:16
                    //     ./in.cue:99:13
                    //     ./in.cue:100:13
                    //     ./in.cue:100:33
                    c: (int){ 1 }
                  }
                }
              }, (null){ null }) }
          }
        }
      }
      b: (struct){
        n1: (struct){
          p1: (struct){
            x: ((null|struct)){ |((struct){
                a: (_|_){
                  // [incomplete] nestedNonMonotonic.incomplete.b.n1.p1.x.a: invalid value {c:1,d:1} (does not satisfy struct.MinFields(3)): len(fields) < MinFields(3) (2 < 3):
                  //     ./in.cue:105:13
                  //     ./in.cue:105:10
                  //     ./in.cue:105:30
                  //     ./in.cue:106:10
                  //     ./in.cue:107:10
                  c: (int){ 1 }
                  d: (int){ 1 }
                }
              }, (null){ null }) }
          }
          p2: (struct){
            x: ((null|struct)){ |((struct){
                a: (_|_){
                  // [incomplete] nestedNonMonotonic.incomplete.b.n1.p2.x.a: invalid value {c:1,d:1} (does not satisfy struct.MinFields(3)): len(fields) < MinFields(3) (2 < 3):
                  //     ./in.cue:112:13
                  //     ./in.cue:111:10
                  //     ./in.cue:112:10
                  //     ./in.cue:112:30
                  //     ./in.cue:113:10
                  c: (int){ 1 }
                  d: (int){ 1 }
                }
              }, (null){ null }) }
          }
          p3: (struct){
            x: ((null|struct)){ |((struct){
                a: (_|_){
                  // [incomplete] nestedNonMonotonic.incomplete.b.n1.p3.x.a: invalid value {c:1,d:1} (does not satisfy struct.MinFields(3)): len(fields) < MinFields(3) (2 < 3):
                  //     ./in.cue:119:13
                  //     ./in.cue:117:10
                  //     ./in.cue:118:10
                  //     ./in.cue:119:10
                  //     ./in.cue:119:30
                  c: (int){ 1 }
                  d: (int){ 1 }
                }
              }, (null){ null }) }
          }
        }
        n2: (struct){
          p1: (struct){
            x: ((null|struct)){ |((struct){
                a: (struct){
                  b: (_|_){
                    // [incomplete] nestedNonMonotonic.incomplete.b.n2.p1.x.a.b: invalid value {c:1,d:1} (does not satisfy struct.MinFields(3)): len(fields) < MinFields(3) (2 < 3):
                    //     ./in.cue:137:16
                    //     ./in.cue:123:13
                    //     ./in.cue:124:13
                    //     ./in.cue:125:13
                    //     ./in.cue:129:13
                    //     ./in.cue:130:13
                    //     ./in.cue:131:13
                    //     ./in.cue:135:13
                    //     ./in.cue:136:13
                    //     ./in.cue:137:13
                    //     ./in.cue:137:33
                    c: (int){ 1 }
                    d: (int){ 1 }
                  }
                }
              }, (null){ null }) }
          }
        }
      }
    }
  }
  preserveClosedness: (struct){
    small: (struct){
      p1: (struct){
        #A: (#struct){ |(*(#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            b: (int){ int }
          }) }
        #B: (#struct){ |(*(#struct){
          }, (#struct){
            b: (int){ int }
          }, (#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            b: (int){ int }
          }) }
      }
      p2: (struct){
        #A: (#struct){ |(*(#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            b: (int){ int }
          }) }
        #B: (#struct){ |(*(#struct){
          }, (#struct){
            a: (string){ string }
            b: (int){ int }
          }, (#struct){
            a: (string){ string }
          }, (#struct){
            b: (int){ int }
          }) }
      }
    }
    medium: (struct){
      p1: (struct){
        #A: (#struct){ |(*(#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }) }
        #B: (#struct){ |(*(#struct){
          }, (#struct){
            c: (int){ int }
          }, (#struct){
            d: (string){ string }
          }, (#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }, (#struct){
            b: (string){ string }
          }, (#struct){
            b: (string){ string }
            c: (int){ int }
          }, (#struct){
            b: (string){ string }
            d: (string){ string }
          }) }
      }
      p2: (struct){
        #A: (#struct){ |(*(#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }) }
        #B: (#struct){ |(*(#struct){
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }, (#struct){
            a: (string){ string }
          }, (#struct){
            c: (int){ int }
          }, (#struct){
            d: (string){ string }
          }, (#struct){
            b: (string){ string }
          }, (#struct){
            b: (string){ string }
            c: (int){ int }
          }, (#struct){
            b: (string){ string }
            d: (string){ string }
          }) }
      }
      p3: (struct){
        #A: (#struct){ |(*(#struct){
            a: (string){ string }
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }) }
        #B: (#struct){ |(*(#struct){
          }, (#struct){
            a: (string){ string }
            c: (int){ int }
          }, (#struct){
            a: (string){ string }
            d: (string){ string }
          }, (#struct){
            b: (string){ string }
          }, (#struct){
            b: (string){ string }
            c: (int){ int }
          }, (#struct){
            b: (string){ string }
            d: (string){ string }
          }, (#struct){
            a: (string){ string }
          }, (#struct){
            c: (int){ int }
          }, (#struct){
            d: (string){ string }
          }) }
      }
    }
  }
}
-- out/compile --
--- in.cue
{
  disambiguateClosed: {
    b: (〈0;#Def〉 & 〈0;a〉)
    a: 〈0;#Def〉
    #Def: {
      ({
        x: true
      }|{
        y: true
      })
    }
  }
  alwaysCheckMatchers1: {
    b: ({
      [=~"^xxxx$"]: int
    }|null)
    b: ({
      c: string
    }|null)
    b: {
      c: "yyyyy"
    }
  }
  alwaysCheckPatterns2: {
    a: 〈0;#X〉
    a: 〈0;b〉
    b: 〈0;#X〉
    b: {
      c: "yyyyy"
    }
    #X: (string|{
      c: string
      {
        [=~"^xxxx$"]: int
      }
    })
  }
  nestedNonMonotonic: {
    resolved: {
      n1: {
        x: ({
          a: 〈import;struct〉.MinFields(2)
        }|null)
        x: ({
          a: {
            c: 1
          }
        }|null)
        x: ({
          a: {
            d: 1
          }
        }|null)
      }
    }
  }
  nestedNonMonotonic: {
    resolved: {
      n2: {
        x: ({
          a: {
            b: 〈import;struct〉.MinFields(2)
          }
        }|null)
        x: ({
          a: {
            b: {
              c: 1
            }
          }
        }|null)
        x: ({
          a: {
            b: {
              d: 1
            }
          }
        }|null)
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n1: {
        p1: {
          x: ({
            a: 〈import;struct〉.MaxFields(1)
          }|null)
          x: ({
            a: {
              c: 1
            }
          }|null)
          x: ({
            a: {
              d: 1
            }
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n1: {
        p2: {
          x: ({
            a: {
              c: 1
            }
          }|null)
          x: ({
            a: 〈import;struct〉.MaxFields(1)
          }|null)
          x: ({
            a: {
              d: 1
            }
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n1: {
        p2: {
          x: ({
            a: {
              c: 1
            }
          }|null)
          x: ({
            a: {
              d: 1
            }
          }|null)
          x: ({
            a: 〈import;struct〉.MaxFields(1)
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n2: {
        p1: {
          x: ({
            a: {
              b: 〈import;struct〉.MaxFields(1)
            }
          }|null)
          x: ({
            a: {
              b: {
                c: 1
              }
            }
          }|null)
          x: ({
            a: {
              b: {
                d: 1
              }
            }
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n2: {
        p2: {
          x: ({
            a: {
              b: {
                c: 1
              }
            }
          }|null)
          x: ({
            a: {
              b: 〈import;struct〉.MaxFields(1)
            }
          }|null)
          x: ({
            a: {
              b: {
                d: 1
              }
            }
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    eliminated: {
      n2: {
        p2: {
          x: ({
            a: {
              b: {
                c: 1
              }
            }
          }|null)
          x: ({
            a: {
              b: {
                d: 1
              }
            }
          }|null)
          x: ({
            a: {
              b: 〈import;struct〉.MaxFields(1)
            }
          }|null)
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      a: {
        n1: {
          p1: {
            x: ({
              a: 〈import;struct〉.MinFields(2)
            }|null)
            x: ({
              a: {
                c: 1
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      a: {
        n1: {
          p2: {
            x: ({
              a: {
                c: 1
              }
            }|null)
            x: ({
              a: 〈import;struct〉.MinFields(2)
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      a: {
        n2: {
          p1: {
            x: ({
              a: {
                b: 〈import;struct〉.MinFields(2)
              }
            }|null)
            x: ({
              a: {
                b: {
                  c: 1
                }
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      a: {
        n2: {
          p2: {
            x: ({
              a: {
                b: {
                  c: 1
                }
              }
            }|null)
            x: ({
              a: {
                b: 〈import;struct〉.MinFields(2)
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n1: {
          p1: {
            x: ({
              a: 〈import;struct〉.MinFields(3)
            }|null)
            x: ({
              a: {
                c: 1
              }
            }|null)
            x: ({
              a: {
                d: 1
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n1: {
          p2: {
            x: ({
              a: {
                c: 1
              }
            }|null)
            x: ({
              a: 〈import;struct〉.MinFields(3)
            }|null)
            x: ({
              a: {
                d: 1
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n1: {
          p3: {
            x: ({
              a: {
                c: 1
              }
            }|null)
            x: ({
              a: {
                d: 1
              }
            }|null)
            x: ({
              a: 〈import;struct〉.MinFields(3)
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n2: {
          p1: {
            x: ({
              a: {
                b: 〈import;struct〉.MinFields(3)
              }
            }|null)
            x: ({
              a: {
                b: {
                  c: 1
                }
              }
            }|null)
            x: ({
              a: {
                b: {
                  d: 1
                }
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n2: {
          p1: {
            x: ({
              a: {
                b: {
                  c: 1
                }
              }
            }|null)
            x: ({
              a: {
                b: 〈import;struct〉.MinFields(3)
              }
            }|null)
            x: ({
              a: {
                b: {
                  d: 1
                }
              }
            }|null)
          }
        }
      }
    }
  }
  nestedNonMonotonic: {
    incomplete: {
      b: {
        n2: {
          p1: {
            x: ({
              a: {
                b: {
                  c: 1
                }
              }
            }|null)
            x: ({
              a: {
                b: {
                  d: 1
                }
              }
            }|null)
            x: ({
              a: {
                b: 〈import;struct〉.MinFields(3)
              }
            }|null)
          }
        }
      }
    }
  }
  preserveClosedness: {
    small: {
      p1: {
        #A: (〈0;#B〉 & {
          a: string
        })
        #B: {
          (*{}|{
            a: string
          })
          (*{}|{
            b: int
          })
        }
      }
    }
  }
  preserveClosedness: {
    small: {
      p2: {
        #A: (〈0;#B〉 & {
          a: string
        })
        #B: {
          ({
            a: string
          }|*{})
          (*{}|{
            b: int
          })
        }
      }
    }
  }
  preserveClosedness: {
    medium: {
      p1: {
        #A: (〈0;#B〉 & {
          a: string
        })
        #B: {
          (*{}|{
            a: string
          }|{
            b: string
          })
          (*{}|{
            c: int
          }|{
            d: string
          })
        }
      }
    }
  }
  preserveClosedness: {
    medium: {
      p2: {
        #A: (〈0;#B〉 & {
          a: string
        })
        #B: {
          ({
            a: string
          }|*{}|{
            b: string
          })
          (*{}|{
            c: int
          }|{
            d: string
          })
        }
      }
    }
  }
  preserveClosedness: {
    medium: {
      p3: {
        #A: (〈0;#B〉 & {
          a: string
        })
        #B: {
          ({
            a: string
          }|{
            b: string
          }|*{})
          (*{}|{
            c: int
          }|{
            d: string
          })
        }
      }
    }
  }
}