github.com/joomcode/cue@v0.4.4-0.20221111115225-539fe3512047/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:12
                  //     ./in.cue:84:29
                  //     ./in.cue:85:9
                  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:12
                  //     ./in.cue:89:9
                  //     ./in.cue:90:29
                  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:15
                    //     ./in.cue:94:32
                    //     ./in.cue:95:12
                    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:15
                    //     ./in.cue:99:12
                    //     ./in.cue:100:32
                    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:104:12
                  //     ./in.cue:104:29
                  //     ./in.cue:105:9
                  //     ./in.cue:106:9
                  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:111:12
                  //     ./in.cue:110:9
                  //     ./in.cue:111:29
                  //     ./in.cue:112:9
                  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:118:12
                  //     ./in.cue:116:9
                  //     ./in.cue:117:9
                  //     ./in.cue:118:29
                  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:136:15
                    //     ./in.cue:122:15
                    //     ./in.cue:123:12
                    //     ./in.cue:124:12
                    //     ./in.cue:128:12
                    //     ./in.cue:129:15
                    //     ./in.cue:130:12
                    //     ./in.cue:134:12
                    //     ./in.cue:135:12
                    //     ./in.cue:136:32
                    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
          })
        }
      }
    }
  }
}