cuelang.org/go@v0.13.0/cue/testdata/eval/required.txtar (about)

     1  -- in.cue --
     2  self: t1: {
     3  	a?: int
     4  }
     5  
     6  self: t2: {
     7  	a!: int
     8  	a!: int
     9  }
    10  
    11  unify: t1: p1: {
    12  	a!: int
    13  	a: int
    14  }
    15  
    16  unify: t1: p2: {
    17  	a: int
    18  	a!: int
    19  }
    20  
    21  unify: t2: p1: {
    22  	a!: int
    23  	a?: int
    24  }
    25  
    26  unify: t2: p2: {
    27  	a?: int
    28  	a!: int
    29  }
    30  #Def: t1: {
    31  	a!: int
    32  }
    33  
    34  allowed: issue2306: {
    35  	#A: a!: int
    36  	#A: #B
    37  
    38  	#B: b!: int
    39  }
    40  
    41  reference: {
    42  	toWithinDefinition: p1:{
    43  		#Foo: a!: int
    44  		b: #Foo.a
    45  	}
    46  	toWithinDefinition: p2:{
    47  		b: #Foo.a
    48  		#Foo: a!: int
    49  	}
    50  	toFieldFromDefinition: p1: {
    51  		#Foo: a!: int
    52  		b: #Foo
    53  		c: b.a
    54  	}
    55  	toFieldFromDefinition: p2: {
    56  		c: b.a
    57  		b: #Foo
    58  		#Foo: a!: int
    59  	}
    60  	toNonDefinition: p1: {
    61  		x: y!: _
    62  		b: x.y
    63  	}
    64  	toNonDefinition: p2: {
    65  		b: x.y
    66  		x: y!: _
    67  	}
    68  	toConcrete: p1: {
    69  		a!: 1
    70  		b: a + 1
    71  	}
    72  	toConcrete: p2: {
    73  		b: a + 1
    74  		a!: 1
    75  	}
    76  }
    77  
    78  -- out/compile --
    79  --- in.cue
    80  {
    81    self: {
    82      t1: {
    83        a?: int
    84      }
    85    }
    86    self: {
    87      t2: {
    88        a!: int
    89        a!: int
    90      }
    91    }
    92    unify: {
    93      t1: {
    94        p1: {
    95          a!: int
    96          a: int
    97        }
    98      }
    99    }
   100    unify: {
   101      t1: {
   102        p2: {
   103          a: int
   104          a!: int
   105        }
   106      }
   107    }
   108    unify: {
   109      t2: {
   110        p1: {
   111          a!: int
   112          a?: int
   113        }
   114      }
   115    }
   116    unify: {
   117      t2: {
   118        p2: {
   119          a?: int
   120          a!: int
   121        }
   122      }
   123    }
   124    #Def: {
   125      t1: {
   126        a!: int
   127      }
   128    }
   129    allowed: {
   130      issue2306: {
   131        #A: {
   132          a!: int
   133        }
   134        #A: 〈0;#B〉
   135        #B: {
   136          b!: int
   137        }
   138      }
   139    }
   140    reference: {
   141      toWithinDefinition: {
   142        p1: {
   143          #Foo: {
   144            a!: int
   145          }
   146          b: 〈0;#Foo〉.a
   147        }
   148      }
   149      toWithinDefinition: {
   150        p2: {
   151          b: 〈0;#Foo〉.a
   152          #Foo: {
   153            a!: int
   154          }
   155        }
   156      }
   157      toFieldFromDefinition: {
   158        p1: {
   159          #Foo: {
   160            a!: int
   161          }
   162          b: 〈0;#Foo〉
   163          c: 〈0;b〉.a
   164        }
   165      }
   166      toFieldFromDefinition: {
   167        p2: {
   168          c: 〈0;b〉.a
   169          b: 〈0;#Foo〉
   170          #Foo: {
   171            a!: int
   172          }
   173        }
   174      }
   175      toNonDefinition: {
   176        p1: {
   177          x: {
   178            y!: _
   179          }
   180          b: 〈0;x〉.y
   181        }
   182      }
   183      toNonDefinition: {
   184        p2: {
   185          b: 〈0;x〉.y
   186          x: {
   187            y!: _
   188          }
   189        }
   190      }
   191      toConcrete: {
   192        p1: {
   193          a!: 1
   194          b: (〈0;a〉 + 1)
   195        }
   196      }
   197      toConcrete: {
   198        p2: {
   199          b: (〈0;a〉 + 1)
   200          a!: 1
   201        }
   202      }
   203    }
   204  }
   205  -- out/eval/stats --
   206  Leaks:  0
   207  Freed:  66
   208  Reused: 58
   209  Allocs: 8
   210  Retain: 10
   211  
   212  Unifications: 66
   213  Conjuncts:    90
   214  Disjuncts:    76
   215  -- out/evalalpha --
   216  (_|_){
   217    // [eval]
   218    self: (struct){
   219      t1: (struct){
   220        a?: (int){ int }
   221      }
   222      t2: (struct){
   223        a!: (int){ int }
   224      }
   225    }
   226    unify: (struct){
   227      t1: (struct){
   228        p1: (struct){
   229          a: (int){ int }
   230        }
   231        p2: (struct){
   232          a: (int){ int }
   233        }
   234      }
   235      t2: (struct){
   236        p1: (struct){
   237          a!: (int){ int }
   238        }
   239        p2: (struct){
   240          a!: (int){ int }
   241        }
   242      }
   243    }
   244    #Def: (#struct){
   245      t1: (#struct){
   246        a!: (int){ int }
   247      }
   248    }
   249    allowed: (_|_){
   250      // [eval]
   251      issue2306: (_|_){
   252        // [eval]
   253        #A: (_|_){
   254          // [eval]
   255          a!: (_|_){
   256            // [eval] allowed.issue2306.#A.a: field not allowed:
   257            //     ./in.cue:34:6
   258          }
   259          b!: (int){ int }
   260        }
   261        #B: (#struct){
   262          b!: (int){ int }
   263        }
   264      }
   265    }
   266    reference: (struct){
   267      toWithinDefinition: (struct){
   268        p1: (struct){
   269          #Foo: (#struct){
   270            a!: (int){ int }
   271          }
   272          b: (int){ int }
   273        }
   274        p2: (struct){
   275          b: (int){ int }
   276          #Foo: (#struct){
   277            a!: (int){ int }
   278          }
   279        }
   280      }
   281      toFieldFromDefinition: (struct){
   282        p1: (struct){
   283          #Foo: (#struct){
   284            a!: (int){ int }
   285          }
   286          b: ~(reference.toFieldFromDefinition.p1.#Foo)
   287          c: (int){ int }
   288        }
   289        p2: (struct){
   290          c: (int){ int }
   291          b: ~(reference.toFieldFromDefinition.p2.#Foo)
   292          #Foo: (#struct){
   293            a!: (int){ int }
   294          }
   295        }
   296      }
   297      toNonDefinition: (struct){
   298        p1: (struct){
   299          x: (struct){
   300            y!: (_){ _ }
   301          }
   302          b: (_){ _ }
   303        }
   304        p2: (struct){
   305          b: (_){ _ }
   306          x: (struct){
   307            y!: (_){ _ }
   308          }
   309        }
   310      }
   311      toConcrete: (struct){
   312        p1: (struct){
   313          a!: (int){ 1 }
   314          b: (int){ 2 }
   315        }
   316        p2: (struct){
   317          b: (int){ 2 }
   318          a!: (int){ 1 }
   319        }
   320      }
   321    }
   322  }
   323  -- diff/-out/evalalpha<==>+out/eval --
   324  diff old new
   325  --- old
   326  +++ new
   327  @@ -40,8 +40,6 @@
   328           a!: (_|_){
   329             // [eval] allowed.issue2306.#A.a: field not allowed:
   330             //     ./in.cue:34:6
   331  -          //     ./in.cue:35:6
   332  -          //     ./in.cue:37:6
   333           }
   334           b!: (int){ int }
   335         }
   336  @@ -70,16 +68,12 @@
   337           #Foo: (#struct){
   338             a!: (int){ int }
   339           }
   340  -        b: (#struct){
   341  -          a!: (int){ int }
   342  -        }
   343  -        c: (int){ int }
   344  -      }
   345  -      p2: (struct){
   346  -        c: (int){ int }
   347  -        b: (#struct){
   348  -          a!: (int){ int }
   349  -        }
   350  +        b: ~(reference.toFieldFromDefinition.p1.#Foo)
   351  +        c: (int){ int }
   352  +      }
   353  +      p2: (struct){
   354  +        c: (int){ int }
   355  +        b: ~(reference.toFieldFromDefinition.p2.#Foo)
   356           #Foo: (#struct){
   357             a!: (int){ int }
   358           }
   359  -- diff/todo/p2 --
   360  Missing position.
   361  -- out/eval --
   362  (_|_){
   363    // [eval]
   364    self: (struct){
   365      t1: (struct){
   366        a?: (int){ int }
   367      }
   368      t2: (struct){
   369        a!: (int){ int }
   370      }
   371    }
   372    unify: (struct){
   373      t1: (struct){
   374        p1: (struct){
   375          a: (int){ int }
   376        }
   377        p2: (struct){
   378          a: (int){ int }
   379        }
   380      }
   381      t2: (struct){
   382        p1: (struct){
   383          a!: (int){ int }
   384        }
   385        p2: (struct){
   386          a!: (int){ int }
   387        }
   388      }
   389    }
   390    #Def: (#struct){
   391      t1: (#struct){
   392        a!: (int){ int }
   393      }
   394    }
   395    allowed: (_|_){
   396      // [eval]
   397      issue2306: (_|_){
   398        // [eval]
   399        #A: (_|_){
   400          // [eval]
   401          a!: (_|_){
   402            // [eval] allowed.issue2306.#A.a: field not allowed:
   403            //     ./in.cue:34:6
   404            //     ./in.cue:35:6
   405            //     ./in.cue:37:6
   406          }
   407          b!: (int){ int }
   408        }
   409        #B: (#struct){
   410          b!: (int){ int }
   411        }
   412      }
   413    }
   414    reference: (struct){
   415      toWithinDefinition: (struct){
   416        p1: (struct){
   417          #Foo: (#struct){
   418            a!: (int){ int }
   419          }
   420          b: (int){ int }
   421        }
   422        p2: (struct){
   423          b: (int){ int }
   424          #Foo: (#struct){
   425            a!: (int){ int }
   426          }
   427        }
   428      }
   429      toFieldFromDefinition: (struct){
   430        p1: (struct){
   431          #Foo: (#struct){
   432            a!: (int){ int }
   433          }
   434          b: (#struct){
   435            a!: (int){ int }
   436          }
   437          c: (int){ int }
   438        }
   439        p2: (struct){
   440          c: (int){ int }
   441          b: (#struct){
   442            a!: (int){ int }
   443          }
   444          #Foo: (#struct){
   445            a!: (int){ int }
   446          }
   447        }
   448      }
   449      toNonDefinition: (struct){
   450        p1: (struct){
   451          x: (struct){
   452            y!: (_){ _ }
   453          }
   454          b: (_){ _ }
   455        }
   456        p2: (struct){
   457          b: (_){ _ }
   458          x: (struct){
   459            y!: (_){ _ }
   460          }
   461        }
   462      }
   463      toConcrete: (struct){
   464        p1: (struct){
   465          a!: (int){ 1 }
   466          b: (int){ 2 }
   467        }
   468        p2: (struct){
   469          b: (int){ 2 }
   470          a!: (int){ 1 }
   471        }
   472      }
   473    }
   474  }