1-- in.cue --
2 let A = 3 * 3
3let B = A + A
4let C = B + B
5let D = C + C
6let E = D + D
7let F = E + E
8b: {
9 let G = F + F
10 let H = G + G
11 let I = H + H
12 let J = I + I
13 let K = J + J
14 let L = K + K
15 let M = L + L
16 let N = M + M
17 let O = N + N
18 let P = O + O
19 let Q = P + P
20 let R = Q + Q
21 let S = R + R
22 let T = S + S
23
24 a: T
25 b: F
26}
27issue1828: {
28 volumes: L3
29
30 let L3 = {
31 for v2 in [for v1 in L2 {}] {}
32 }
33
34 let L2 = L1
35 let L1 = []
36}
37ignoreErrorInLet: {
38 let X = 1 & 2
39 disjunction: *X | 3
40}
41-- incomprehension.cue --
42// for comprehensions in list do not have to split the let as each instance
43// is already associated with a separate environment.
44list: {
45 l: [ 1, 2, 3 ]
46 c: [
47 for v in l {
48 let X = v*4 // can share
49 X
50 }
51 ]
52}
53
54referencesForDirectly: {
55 l: [ 1, 2, 3 ]
56 for k, v in l {
57 let Y = v*4 // multi
58 "\(k)": Y
59 }
60}
61
62referencesForViaLet: {
63 l: [ 1, 2, 3 ]
64 for k, v in l let X = v*4 {
65 let Y = X // multi
66 "\(k)": Y
67 }
68}
69
70letClauseReferencesInert: {
71 x: 2
72 l: [ 1, 2, 3 ]
73 for k, v in l let X = x {
74 let Y = X // can share
75 "\(k)": Y
76 }
77}
78
79// for indirect references, it is okay to not "split" a let clause, as the
80// it will only fail as a result of not splitting if the referred values
81// would fail as well.
82indirectReference: {
83 l: [ 1, 2, 3 ]
84 for k, v in l {
85 y: v // fails if v differs for each y.
86 let X = y*4 // can share, as y fails if let fails.
87 "\(k)": X
88 }
89}
90
91nestedFor: {
92 for k, y in [ 4, 5 ] {
93 let X = {
94 for x in [ 1, 2 ] {
95 let X = x
96 "\(X)": X
97 }
98 }
99 "\(k)": X
100 }
101}
102
103-- issue2166.cue --
104letWithDynamicInComprehension: {
105 _i: {
106 a: "d"
107 b: "e"
108 }
109
110 for k, v in _i {
111 let T = v
112 (T): "1"
113 }
114}
115-- issue2218.cue --
116_parent_configs: {
117 PARENT: true
118}
119_configs: {
120 CHILD1: {
121 property: true
122 }
123 CHILD2: {
124 property: true
125 parent: "PARENT"
126 }
127}
128disabled_parent_test: {for k, v in _configs {
129 let parent_config = (*_parent_configs[v.parent] | false)
130 "\(k)": {
131 "parent_config": parent_config
132 }
133}}
134-- issue2063.cue --
135import (
136 "encoding/yaml"
137 "strings"
138)
139
140// Issue #2063
141keepDescending: t1: {
142 ec: {}
143 bs: {
144 let m = ec.b
145 if m == _|_ { }
146 x: y: ""
147 }
148}
149
150keepDescending: t2: {
151 x: yaml.Marshal(bs)
152
153 ec: {}
154 bs: {
155 let m = ec.b
156 if m.b == _|_ { }
157 X: Y: strings.Join([], "")
158 }
159}
160
161-- out/eval/stats --
162Leaks: 51
163Freed: 159
164Reused: 150
165Allocs: 60
166Retain: 188
167
168Unifications: 196
169Conjuncts: 373
170Disjuncts: 248
171-- out/eval --
172Errors:
173indirectReference.y: conflicting values 2 and 1:
174 ./incomprehension.cue:42:7
175 ./incomprehension.cue:42:10
176 ./incomprehension.cue:43:2
177 ./incomprehension.cue:44:6
178indirectReference.y: conflicting values 3 and 1:
179 ./incomprehension.cue:42:7
180 ./incomprehension.cue:42:13
181 ./incomprehension.cue:43:2
182 ./incomprehension.cue:44:6
183
184Result:
185(_|_){
186 // [eval]
187 let A#1 = (int){ 9 }
188 let B#2 = (int){ 18 }
189 let C#3 = (int){ 36 }
190 let D#4 = (int){ 72 }
191 let E#5 = (int){ 144 }
192 let F#6 = (int){ 288 }
193 b: (struct){
194 let G#7 = (int){ 576 }
195 let H#8 = (int){ 1152 }
196 let I#9 = (int){ 2304 }
197 let J#A = (int){ 4608 }
198 let K#B = (int){ 9216 }
199 let L#C = (int){ 18432 }
200 let M#D = (int){ 36864 }
201 let N#E = (int){ 73728 }
202 let O#F = (int){ 147456 }
203 let P#10 = (int){ 294912 }
204 let Q#11 = (int){ 589824 }
205 let R#12 = (int){ 1179648 }
206 let S#13 = (int){ 2359296 }
207 let T#14 = (int){ 4718592 }
208 a: (int){ 4718592 }
209 b: (int){ 288 }
210 }
211 issue1828: (struct){
212 volumes: (struct){
213 }
214 let L3#15 = (struct){
215 }
216 let L2#16 = (#list){
217 }
218 let L1#17 = (#list){
219 }
220 }
221 ignoreErrorInLet: (struct){
222 let X#18 = (_|_){
223 // [eval] ignoreErrorInLet.X: conflicting values 2 and 1:
224 // ./in.cue:37:10
225 // ./in.cue:37:14
226 }
227 disjunction: (int){ 3 }
228 }
229 list: (struct){
230 l: (#list){
231 0: (int){ 1 }
232 1: (int){ 2 }
233 2: (int){ 3 }
234 }
235 c: (#list){
236 0: (int){
237 4
238 let X#19 = (int){ 4 }
239 }
240 1: (int){
241 8
242 let X#19 = (int){ 8 }
243 }
244 2: (int){
245 12
246 let X#19 = (int){ 12 }
247 }
248 }
249 }
250 referencesForDirectly: (struct){
251 l: (#list){
252 0: (int){ 1 }
253 1: (int){ 2 }
254 2: (int){ 3 }
255 }
256 let Y#1Amulti = (〈1;v〉 * 4)
257 "0": (int){ 4 }
258 "1": (int){ 8 }
259 "2": (int){ 12 }
260 }
261 referencesForViaLet: (struct){
262 l: (#list){
263 0: (int){ 1 }
264 1: (int){ 2 }
265 2: (int){ 3 }
266 }
267 let Y#1Bmulti = 〈1;X〉
268 "0": (int){ 4 }
269 "1": (int){ 8 }
270 "2": (int){ 12 }
271 }
272 letClauseReferencesInert: (struct){
273 x: (int){ 2 }
274 l: (#list){
275 0: (int){ 1 }
276 1: (int){ 2 }
277 2: (int){ 3 }
278 }
279 let Y#1C = (int){ 2 }
280 "0": (int){ 2 }
281 "1": (int){ 2 }
282 "2": (int){ 2 }
283 }
284 indirectReference: (_|_){
285 // [eval]
286 l: (#list){
287 0: (int){ 1 }
288 1: (int){ 2 }
289 2: (int){ 3 }
290 }
291 y: (_|_){
292 // [eval] indirectReference.y: conflicting values 2 and 1:
293 // ./incomprehension.cue:42:7
294 // ./incomprehension.cue:42:10
295 // ./incomprehension.cue:43:2
296 // ./incomprehension.cue:44:6
297 // indirectReference.y: conflicting values 3 and 1:
298 // ./incomprehension.cue:42:7
299 // ./incomprehension.cue:42:13
300 // ./incomprehension.cue:43:2
301 // ./incomprehension.cue:44:6
302 }
303 let X#1D = (_|_){
304 // [eval] indirectReference.y: conflicting values 2 and 1:
305 // ./incomprehension.cue:42:7
306 // ./incomprehension.cue:42:10
307 // ./incomprehension.cue:43:2
308 // ./incomprehension.cue:44:6
309 // indirectReference.y: conflicting values 3 and 1:
310 // ./incomprehension.cue:42:7
311 // ./incomprehension.cue:42:13
312 // ./incomprehension.cue:43:2
313 // ./incomprehension.cue:44:6
314 }
315 "0": (_|_){
316 // [eval] indirectReference.y: conflicting values 2 and 1:
317 // ./incomprehension.cue:42:7
318 // ./incomprehension.cue:42:10
319 // ./incomprehension.cue:43:2
320 // ./incomprehension.cue:44:6
321 // indirectReference.y: conflicting values 3 and 1:
322 // ./incomprehension.cue:42:7
323 // ./incomprehension.cue:42:13
324 // ./incomprehension.cue:43:2
325 // ./incomprehension.cue:44:6
326 }
327 "1": (_|_){
328 // [eval] indirectReference.y: conflicting values 2 and 1:
329 // ./incomprehension.cue:42:7
330 // ./incomprehension.cue:42:10
331 // ./incomprehension.cue:43:2
332 // ./incomprehension.cue:44:6
333 // indirectReference.y: conflicting values 3 and 1:
334 // ./incomprehension.cue:42:7
335 // ./incomprehension.cue:42:13
336 // ./incomprehension.cue:43:2
337 // ./incomprehension.cue:44:6
338 }
339 "2": (_|_){
340 // [eval] indirectReference.y: conflicting values 2 and 1:
341 // ./incomprehension.cue:42:7
342 // ./incomprehension.cue:42:10
343 // ./incomprehension.cue:43:2
344 // ./incomprehension.cue:44:6
345 // indirectReference.y: conflicting values 3 and 1:
346 // ./incomprehension.cue:42:7
347 // ./incomprehension.cue:42:13
348 // ./incomprehension.cue:43:2
349 // ./incomprehension.cue:44:6
350 }
351 }
352 nestedFor: (struct){
353 let X#1Emulti = {
354 for _, x in [
355 1,
356 2,
357 ] {
358 let X#1Fmulti = 〈1;x〉
359 "\(〈0;let X#1F〉)": 〈0;let X#1F〉
360 }
361 }
362 "0": (struct){
363 let X#1Fmulti = 〈1;x〉
364 "1": (int){ 1 }
365 "2": (int){ 2 }
366 }
367 "1": (struct){
368 let X#1Fmulti = 〈1;x〉
369 "1": (int){ 1 }
370 "2": (int){ 2 }
371 }
372 }
373 keepDescending: (struct){
374 t1: (struct){
375 ec: (struct){
376 }
377 bs: (struct){
378 let m#21 = (_|_){
379 // [incomplete] keepDescending.t1.bs.m: undefined field: b:
380 // ./issue2063.cue:10:14
381 }
382 x: (struct){
383 y: (string){ "" }
384 }
385 }
386 }
387 t2: (struct){
388 x: (string){ "X:\n \"Y\": \"\"\n" }
389 ec: (struct){
390 }
391 bs: (struct){
392 let m#22 = (_|_){
393 // [incomplete] keepDescending.t2.bs.m: undefined field: b:
394 // ./issue2063.cue:21:14
395 }
396 X: (struct){
397 Y: (string){ "" }
398 }
399 }
400 }
401 }
402 letWithDynamicInComprehension: (struct){
403 _i: (struct){
404 a: (string){ "d" }
405 b: (string){ "e" }
406 }
407 let T#23multi = 〈1;v〉
408 d: (string){ "1" }
409 e: (string){ "1" }
410 }
411 _parent_configs: (struct){
412 PARENT: (bool){ true }
413 }
414 _configs: (struct){
415 CHILD1: (struct){
416 property: (bool){ true }
417 }
418 CHILD2: (struct){
419 property: (bool){ true }
420 parent: (string){ "PARENT" }
421 }
422 }
423 disabled_parent_test: (struct){
424 let parent_config#24multi = (*〈3;_parent_configs〉[〈1;v〉.parent]|false)
425 CHILD1: (struct){
426 parent_config: (bool){ false }
427 }
428 CHILD2: (struct){
429 parent_config: (bool){ |(*(bool){ true }, (bool){ false }) }
430 }
431 }
432}
433-- out/compile --
434--- in.cue
435{
436 let A#1 = (3 * 3)
437 let B#2 = (〈0;let A#1〉 + 〈0;let A#1〉)
438 let C#3 = (〈0;let B#2〉 + 〈0;let B#2〉)
439 let D#4 = (〈0;let C#3〉 + 〈0;let C#3〉)
440 let E#5 = (〈0;let D#4〉 + 〈0;let D#4〉)
441 let F#6 = (〈0;let E#5〉 + 〈0;let E#5〉)
442 b: {
443 let G#7 = (〈1;let F#6〉 + 〈1;let F#6〉)
444 let H#8 = (〈0;let G#7〉 + 〈0;let G#7〉)
445 let I#9 = (〈0;let H#8〉 + 〈0;let H#8〉)
446 let J#A = (〈0;let I#9〉 + 〈0;let I#9〉)
447 let K#B = (〈0;let J#A〉 + 〈0;let J#A〉)
448 let L#C = (〈0;let K#B〉 + 〈0;let K#B〉)
449 let M#D = (〈0;let L#C〉 + 〈0;let L#C〉)
450 let N#E = (〈0;let M#D〉 + 〈0;let M#D〉)
451 let O#F = (〈0;let N#E〉 + 〈0;let N#E〉)
452 let P#10 = (〈0;let O#F〉 + 〈0;let O#F〉)
453 let Q#11 = (〈0;let P#10〉 + 〈0;let P#10〉)
454 let R#12 = (〈0;let Q#11〉 + 〈0;let Q#11〉)
455 let S#13 = (〈0;let R#12〉 + 〈0;let R#12〉)
456 let T#14 = (〈0;let S#13〉 + 〈0;let S#13〉)
457 a: 〈0;let T#14〉
458 b: 〈1;let F#6〉
459 }
460 issue1828: {
461 volumes: 〈0;let L3#15〉
462 let L3#15 = {
463 for _, v2 in [
464 for _, v1 in 〈2;let L2#16〉 {},
465 ] {}
466 }
467 let L2#16 = 〈0;let L1#17〉
468 let L1#17 = []
469 }
470 ignoreErrorInLet: {
471 let X#18 = (1 & 2)
472 disjunction: (*〈0;let X#18〉|3)
473 }
474}
475--- incomprehension.cue
476{
477 list: {
478 l: [
479 1,
480 2,
481 3,
482 ]
483 c: [
484 for _, v in 〈1;l〉 {
485 let X#19 = (〈1;v〉 * 4)
486 〈0;let X#19〉
487 },
488 ]
489 }
490 referencesForDirectly: {
491 l: [
492 1,
493 2,
494 3,
495 ]
496 for k, v in 〈0;l〉 {
497 let Y#1Amulti = (〈1;v〉 * 4)
498 "\(〈1;k〉)": 〈0;let Y#1A〉
499 }
500 }
501 referencesForViaLet: {
502 l: [
503 1,
504 2,
505 3,
506 ]
507 for k, v in 〈0;l〉 let X = (〈0;v〉 * 4) {
508 let Y#1Bmulti = 〈1;X〉
509 "\(〈2;k〉)": 〈0;let Y#1B〉
510 }
511 }
512 letClauseReferencesInert: {
513 x: 2
514 l: [
515 1,
516 2,
517 3,
518 ]
519 for k, v in 〈0;l〉 let X = 〈1;x〉 {
520 let Y#1C = 〈1;X〉
521 "\(〈2;k〉)": 〈0;let Y#1C〉
522 }
523 }
524 indirectReference: {
525 l: [
526 1,
527 2,
528 3,
529 ]
530 for k, v in 〈0;l〉 {
531 y: 〈1;v〉
532 let X#1D = (〈0;y〉 * 4)
533 "\(〈1;k〉)": 〈0;let X#1D〉
534 }
535 }
536 nestedFor: {
537 for k, y in [
538 4,
539 5,
540 ] {
541 let X#1Emulti = {
542 for _, x in [
543 1,
544 2,
545 ] {
546 let X#1Fmulti = 〈1;x〉
547 "\(〈0;let X#1F〉)": 〈0;let X#1F〉
548 }
549 }
550 "\(〈1;k〉)": 〈0;let X#1E〉
551 }
552 }
553}
554--- issue2063.cue
555{
556 keepDescending: {
557 t1: {
558 ec: {}
559 bs: {
560 let m#21 = 〈1;ec〉.b
561 if (〈0;let m#21〉 == _|_(explicit error (_|_ literal) in source)) {}
562 x: {
563 y: ""
564 }
565 }
566 }
567 }
568 keepDescending: {
569 t2: {
570 x: 〈import;"encoding/yaml"〉.Marshal(〈0;bs〉)
571 ec: {}
572 bs: {
573 let m#22 = 〈1;ec〉.b
574 if (〈0;let m#22〉.b == _|_(explicit error (_|_ literal) in source)) {}
575 X: {
576 Y: 〈import;strings〉.Join([], "")
577 }
578 }
579 }
580 }
581}
582--- issue2166.cue
583{
584 letWithDynamicInComprehension: {
585 _i: {
586 a: "d"
587 b: "e"
588 }
589 for k, v in 〈0;_i〉 {
590 let T#23multi = 〈1;v〉
591 〈0;let T#23〉: "1"
592 }
593 }
594}
595--- issue2218.cue
596{
597 _parent_configs: {
598 PARENT: true
599 }
600 _configs: {
601 CHILD1: {
602 property: true
603 }
604 CHILD2: {
605 property: true
606 parent: "PARENT"
607 }
608 }
609 disabled_parent_test: {
610 for k, v in 〈1;_configs〉 {
611 let parent_config#24multi = (*〈3;_parent_configs〉[〈1;v〉.parent]|false)
612 "\(〈1;k〉)": {
613 parent_config: 〈1;let parent_config#24〉
614 }
615 }
616 }
617}
View as plain text