// TODO: make special benchmark test that tests repeated lines more accurately
// and and automatically.

-- in.cue --
// Should linearly increase with each repeated line.
// automatically.
pat: {[string]: 1} | {a: 2} // 9   conjuncts
pat: {[string]: 1} | {a: 2} // 23  conjuncts (+14)
pat: {[string]: 1} | {a: 2} // 34  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 45  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 56  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 67  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 78  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 89  conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 100 conjuncts (+11)
pat: {[string]: 1} | {a: 2} // 111 conjuncts (+11)

// This also should grow linearly per repeated line.
// Indicated
list: [1] | [2] | [3] | [4] // 19  conjuncts; 4   disjuncts
list: [1] | [2] | [3] | [4] // 52  conjuncts; 20  disjuncts (+33; +16)
list: [1] | [2] | [3] | [4] // 85  conjuncts; 36  disjuncts (+33; +16)
list: [1] | [2] | [3] | [4] // 118 conjuncts; 52  disjuncts (+33; +16)
list: [1] | [2] | [3] | [4] // 151 conjuncts; 68  disjuncts (+33; +16)
list: [1] | [2] | [3] | [4] // 184 conjuncts; 84  disjuncts (+33; +16)
list: [1] | [2] | [3] | [4] // 217 conjuncts; 100 disjuncts (+33; +16)

issue3610: {
	// Ensure disjuncts are disambiguated. The string field here is a reference
	// and causes a task to be added. Ensure that, for instance, disjuncts
	// >"b" and (>"b" & string) get equated when at least the task has
	// completed.
	#a
	#a: <"a" | >"b" | string
	#a: <"a" | >"b" | string // conjuncts 127  disjuncts 120
	#a: <"a" | >"b" | string // conjuncts 219  disjuncts 210 (+92; +90)
	#a: <"a" | >"b" | string // conjuncts 311  disjuncts 300 (+92; +90)
	#a: <"a" | >"b" | string // conjuncts 403  disjuncts 390 (+92; +90)
	#a: <"a" | >"b" | string // conjuncts 495  disjuncts 480 (+92; +90)
}

-- out/evalalpha/stats --
Leaks:  802
Freed:  0
Reused: 0
Allocs: 802
Retain: 0

Unifications: 22
Conjuncts:    843
Disjuncts:    618

CloseIDElems: 63
NumCloseIDs: 4
-- diff/-out/evalalpha/stats<==>+out/eval/stats --
diff old new
--- old
+++ new
@@ -1,9 +1,12 @@
-Leaks:  0
-Freed:  367
-Reused: 356
-Allocs: 11
+Leaks:  802
+Freed:  0
+Reused: 0
+Allocs: 802
 Retain: 0
 
-Unifications: 133
-Conjuncts:    866
-Disjuncts:    367
+Unifications: 22
+Conjuncts:    843
+Disjuncts:    618
+
+CloseIDElems: 63
+NumCloseIDs: 4
-- out/eval/stats --
Leaks:  0
Freed:  367
Reused: 356
Allocs: 11
Retain: 0

Unifications: 133
Conjuncts:    866
Disjuncts:    367
-- out/eval --
(struct){
  pat: (struct){ |((struct){
    }, (struct){
      a: (int){ 2 }
    }) }
  list: (list){ |((#list){
      0: (int){ 1 }
    }, (#list){
      0: (int){ 2 }
    }, (#list){
      0: (int){ 3 }
    }, (#list){
      0: (int){ 4 }
    }) }
  issue3610: (string){ |((string){
      <"a"
      #a: (string){ |((string){ <"a" }, (string){ >"b" }, (string){ string }) }
    }, (string){
      >"b"
      #a: (string){ |((string){ <"a" }, (string){ >"b" }, (string){ string }) }
    }, (string){
      string
      #a: (string){ |((string){ <"a" }, (string){ >"b" }, (string){ string }) }
    }) }
}
-- out/compile --
--- in.cue
{
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  pat: ({
    [string]: 1
  }|{
    a: 2
  })
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  list: ([
    1,
  ]|[
    2,
  ]|[
    3,
  ]|[
    4,
  ])
  issue3610: {
    〈0;#a〉
    #a: (<"a"|>"b"|string)
    #a: (<"a"|>"b"|string)
    #a: (<"a"|>"b"|string)
    #a: (<"a"|>"b"|string)
    #a: (<"a"|>"b"|string)
    #a: (<"a"|>"b"|string)
  }
}
