| -- in.cue -- |
| |
| self: { |
| fail: { |
| a: { |
| if a.b == _|_ { |
| b: 1 |
| } |
| } |
| } |
| isConcreteFail: { |
| a: { |
| if a.b == _|_ { |
| b: 1 |
| } |
| b: int |
| } |
| } |
| isNotConcrete: { |
| a: { |
| if a.b != _|_ { |
| b: 1 |
| } |
| b: int |
| } |
| } |
| } |
| |
| mutual: { |
| noConflicts: { |
| a: { if b.foo == _|_ { new: "" } } |
| b: { if a.bar == _|_ { new: "" } } |
| } |
| |
| mutualCycleFail: { |
| b: { if a.bar == _|_ { foo: "" } } |
| a: { if b.foo == _|_ { bar: "" } } |
| } |
| |
| brokenCycleSuccess: { |
| a: { if b.foo == _|_ { foo: "" } } |
| b: { if a.bar == _|_ { bar: "" } } |
| a: bar: "" |
| } |
| |
| oneDirectionalConflictFail: { |
| p1: { |
| a: { if b.foo == _|_ { bar: "" } } |
| b: { if a.bar == _|_ { new: "" } } |
| } |
| p2: { |
| a: { if b.foo == _|_ { new: "" } } |
| b: { if a.bar == _|_ { foo: "" } } |
| } |
| } |
| |
| oneDirectionalBrokenConflictSuccess: { |
| a: { if b.foo == _|_ { bar: "" } } |
| b: { if a.bar == _|_ { new: "" } } |
| b: foo: "" |
| } |
| } |
| |
| sameStruct: { |
| chainSuccess: { |
| raises?: {} |
| if raises == _|_ { |
| ret: a: 1 |
| } |
| ret?: {} |
| if ret != _|_ { |
| foo: a: 1 |
| } |
| } |
| |
| cycleFail: { |
| raises?: {} |
| if raises == _|_ { |
| ret: a: 1 |
| } |
| ret?: {} |
| if ret != _|_ { |
| raises: a: 1 |
| } |
| } |
| |
| defCloseSuccess: { |
| #Example: { |
| raises?: { |
| runtime?: string |
| } |
| |
| if raises == _|_ { |
| ret?: _ |
| } |
| } |
| |
| expr: #Example & { |
| ret: 2 |
| } |
| } |
| } |
| |
| // Issue |
| nestedChain: { |
| cycleFail: { |
| if #E.x != _|_ { |
| #E: y: true |
| } |
| if #E.y == _|_ { |
| #E: x: true |
| } |
| #E: [_]: bool |
| } |
| |
| brokenCycleSuccess: { |
| if #E.x != _|_ { |
| #E: y: true |
| } |
| if #E.y == _|_ { |
| #E: x: true |
| } |
| #E: [_]: bool |
| #E: x: true |
| } |
| |
| // TODO: the current algorithm does _not_ handle checking fields that were |
| // not added in certain situations. |
| doubleAddfail: { |
| if #E.x == _|_ { |
| #E: y: true |
| } |
| if #E.y == _|_ { |
| #E: x: true |
| } |
| #E: [_]: bool |
| } |
| |
| trippleSuccess: { |
| if #E.x != _|_ { |
| #E: y: true |
| } |
| if #E.y != _|_ { |
| z: true |
| } |
| #E: x: true |
| } |
| } |
| -- out/eval -- |
| Errors: |
| mutual.mutualCycleFail.a: cycle: new field bar inserted by if clause that was previously evaluated by another if clause |
| mutual.oneDirectionalConflictFail.p1.a: cycle: new field bar inserted by if clause that was previously evaluated by another if clause |
| mutual.oneDirectionalConflictFail.p2.b: cycle: new field foo inserted by if clause that was previously evaluated by another if clause |
| nestedChain.cycleFail.#E: cycle: new field x inserted by if clause that was previously evaluated by another if clause |
| sameStruct.cycleFail: cycle: new field raises inserted by if clause that was previously evaluated by another if clause |
| self.fail.a: cycle: new field b inserted by if clause that was previously evaluated by another if clause |
| |
| Result: |
| (_|_){ |
| // [eval] |
| self: (_|_){ |
| // [eval] |
| fail: (_|_){ |
| // [eval] |
| a: (_|_){ |
| // [eval] self.fail.a: cycle: new field b inserted by if clause that was previously evaluated by another if clause |
| b: (int){ 1 } |
| } |
| } |
| isConcreteFail: (struct){ |
| a: (struct){ |
| b: (int){ 1 } |
| } |
| } |
| isNotConcrete: (struct){ |
| a: (struct){ |
| b: (int){ int } |
| } |
| } |
| } |
| mutual: (_|_){ |
| // [eval] |
| noConflicts: (struct){ |
| a: (struct){ |
| new: (string){ "" } |
| } |
| b: (struct){ |
| new: (string){ "" } |
| } |
| } |
| mutualCycleFail: (_|_){ |
| // [eval] |
| b: (struct){ |
| } |
| a: (_|_){ |
| // [eval] mutual.mutualCycleFail.a: cycle: new field bar inserted by if clause that was previously evaluated by another if clause |
| bar: (string){ "" } |
| } |
| } |
| brokenCycleSuccess: (struct){ |
| a: (struct){ |
| bar: (string){ "" } |
| foo: (string){ "" } |
| } |
| b: (struct){ |
| } |
| } |
| oneDirectionalConflictFail: (_|_){ |
| // [eval] |
| p1: (_|_){ |
| // [eval] |
| a: (_|_){ |
| // [eval] mutual.oneDirectionalConflictFail.p1.a: cycle: new field bar inserted by if clause that was previously evaluated by another if clause |
| bar: (string){ "" } |
| } |
| b: (struct){ |
| new: (string){ "" } |
| } |
| } |
| p2: (_|_){ |
| // [eval] |
| a: (struct){ |
| } |
| b: (_|_){ |
| // [eval] mutual.oneDirectionalConflictFail.p2.b: cycle: new field foo inserted by if clause that was previously evaluated by another if clause |
| foo: (string){ "" } |
| } |
| } |
| } |
| oneDirectionalBrokenConflictSuccess: (struct){ |
| a: (struct){ |
| } |
| b: (struct){ |
| foo: (string){ "" } |
| new: (string){ "" } |
| } |
| } |
| } |
| sameStruct: (_|_){ |
| // [eval] |
| chainSuccess: (struct){ |
| ret: (struct){ |
| a: (int){ 1 } |
| } |
| foo: (struct){ |
| a: (int){ 1 } |
| } |
| } |
| cycleFail: (_|_){ |
| // [eval] sameStruct.cycleFail: cycle: new field raises inserted by if clause that was previously evaluated by another if clause |
| ret: (struct){ |
| a: (int){ 1 } |
| } |
| raises: (struct){ |
| a: (int){ 1 } |
| } |
| } |
| defCloseSuccess: (struct){ |
| #Example: (#struct){ |
| } |
| expr: (#struct){ |
| ret: (int){ 2 } |
| } |
| } |
| } |
| nestedChain: (_|_){ |
| // [eval] |
| cycleFail: (_|_){ |
| // [eval] |
| #E: (_|_){ |
| // [eval] nestedChain.cycleFail.#E: cycle: new field x inserted by if clause that was previously evaluated by another if clause |
| x: (bool){ true } |
| } |
| } |
| brokenCycleSuccess: (struct){ |
| #E: (#struct){ |
| x: (bool){ true } |
| y: (bool){ true } |
| } |
| } |
| doubleAddfail: (struct){ |
| #E: (#struct){ |
| y: (bool){ true } |
| } |
| } |
| trippleSuccess: (struct){ |
| #E: (#struct){ |
| x: (bool){ true } |
| y: (bool){ true } |
| } |
| z: (bool){ true } |
| } |
| } |
| } |
| -- out/compile -- |
| --- in.cue |
| { |
| self: { |
| fail: { |
| a: { |
| if (〈1;a〉.b == _|_(explicit error (_|_ literal) in source)) { |
| b: 1 |
| } |
| } |
| } |
| isConcreteFail: { |
| a: { |
| if (〈1;a〉.b == _|_(explicit error (_|_ literal) in source)) { |
| b: 1 |
| } |
| b: int |
| } |
| } |
| isNotConcrete: { |
| a: { |
| if (〈1;a〉.b != _|_(explicit error (_|_ literal) in source)) { |
| b: 1 |
| } |
| b: int |
| } |
| } |
| } |
| mutual: { |
| noConflicts: { |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| new: "" |
| } |
| } |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| new: "" |
| } |
| } |
| } |
| mutualCycleFail: { |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| foo: "" |
| } |
| } |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| bar: "" |
| } |
| } |
| } |
| brokenCycleSuccess: { |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| foo: "" |
| } |
| } |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| bar: "" |
| } |
| } |
| a: { |
| bar: "" |
| } |
| } |
| oneDirectionalConflictFail: { |
| p1: { |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| bar: "" |
| } |
| } |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| new: "" |
| } |
| } |
| } |
| p2: { |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| new: "" |
| } |
| } |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| foo: "" |
| } |
| } |
| } |
| } |
| oneDirectionalBrokenConflictSuccess: { |
| a: { |
| if (〈1;b〉.foo == _|_(explicit error (_|_ literal) in source)) { |
| bar: "" |
| } |
| } |
| b: { |
| if (〈1;a〉.bar == _|_(explicit error (_|_ literal) in source)) { |
| new: "" |
| } |
| } |
| b: { |
| foo: "" |
| } |
| } |
| } |
| sameStruct: { |
| chainSuccess: { |
| raises?: {} |
| if (〈0;raises〉 == _|_(explicit error (_|_ literal) in source)) { |
| ret: { |
| a: 1 |
| } |
| } |
| ret?: {} |
| if (〈0;ret〉 != _|_(explicit error (_|_ literal) in source)) { |
| foo: { |
| a: 1 |
| } |
| } |
| } |
| cycleFail: { |
| raises?: {} |
| if (〈0;raises〉 == _|_(explicit error (_|_ literal) in source)) { |
| ret: { |
| a: 1 |
| } |
| } |
| ret?: {} |
| if (〈0;ret〉 != _|_(explicit error (_|_ literal) in source)) { |
| raises: { |
| a: 1 |
| } |
| } |
| } |
| defCloseSuccess: { |
| #Example: { |
| raises?: { |
| runtime?: string |
| } |
| if (〈0;raises〉 == _|_(explicit error (_|_ literal) in source)) { |
| ret?: _ |
| } |
| } |
| expr: (〈0;#Example〉 & { |
| ret: 2 |
| }) |
| } |
| } |
| nestedChain: { |
| cycleFail: { |
| if (〈0;#E〉.x != _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| y: true |
| } |
| } |
| if (〈0;#E〉.y == _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| x: true |
| } |
| } |
| #E: { |
| [_]: bool |
| } |
| } |
| brokenCycleSuccess: { |
| if (〈0;#E〉.x != _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| y: true |
| } |
| } |
| if (〈0;#E〉.y == _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| x: true |
| } |
| } |
| #E: { |
| [_]: bool |
| } |
| #E: { |
| x: true |
| } |
| } |
| doubleAddfail: { |
| if (〈0;#E〉.x == _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| y: true |
| } |
| } |
| if (〈0;#E〉.y == _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| x: true |
| } |
| } |
| #E: { |
| [_]: bool |
| } |
| } |
| trippleSuccess: { |
| if (〈0;#E〉.x != _|_(explicit error (_|_ literal) in source)) { |
| #E: { |
| y: true |
| } |
| } |
| if (〈0;#E〉.y != _|_(explicit error (_|_ literal) in source)) { |
| z: true |
| } |
| #E: { |
| x: true |
| } |
| } |
| } |
| } |
