-- in.cue --
package p

excludeLet: {
	// Two lets with the same name should not unify and checked by definition.
	#D: { let X = {}, #foo: X, f: _}
	a: #D
	a: { let X = {a: 1}, f: X}
}

definition: {
	// Check a definition only if it s contained withing a definition.
	err1: {
		#D: {#foo: a: int}
		a: #D
		a: {#foo: b: int}
	}
	ok1: {
		#D: {}
		a: #D
		a: {#foo: b: int}
	}
}

hidden: {
	// Check a hidden field only if it s contained withing a definition.
	err1: {
		#D: {_foo: a: int}
		a: #D
		a: {_foo: b: int}
	}
	ok1: {
		#D: {}
		a: #D
		a: {_foo: b: int}
	}
}
-- regress.cue --
package p

import "encoding/json"

definition: ok2: {
	#Tree: {
		#Leaf: leaf:      string
		#Branch: branch?: #Leaf
		root: #Branch
	}
	out: json.Marshal(#Tree & {root: {}})
}

hidden: ok2: {
	out: #Workflow & {
		_hidden: #step & {
			run: "foo bar"
		}
	}
	#Workflow: {}
	#step: matchN(1, [{
		"run"!: _
	}])
}
-- out/compile --
--- in.cue
{
  excludeLet: {
    #D: {
      let X#1 = {}
      #foo: 〈0;let X#1〉
      f: _
    }
    a: 〈0;#D〉
    a: {
      let X#2 = {
        a: 1
      }
      f: 〈0;let X#2〉
    }
  }
  definition: {
    err1: {
      #D: {
        #foo: {
          a: int
        }
      }
      a: 〈0;#D〉
      a: {
        #foo: {
          b: int
        }
      }
    }
    ok1: {
      #D: {}
      a: 〈0;#D〉
      a: {
        #foo: {
          b: int
        }
      }
    }
  }
  hidden: {
    err1: {
      #D: {
        _foo(:p): {
          a: int
        }
      }
      a: 〈0;#D〉
      a: {
        _foo(:p): {
          b: int
        }
      }
    }
    ok1: {
      #D: {}
      a: 〈0;#D〉
      a: {
        _foo(:p): {
          b: int
        }
      }
    }
  }
}
--- regress.cue
{
  definition: {
    ok2: {
      #Tree: {
        #Leaf: {
          leaf: string
        }
        #Branch: {
          branch?: 〈1;#Leaf〉
        }
        root: 〈0;#Branch〉
      }
      out: 〈import;"encoding/json"〉.Marshal((〈0;#Tree〉 & {
        root: {}
      }))
    }
  }
  hidden: {
    ok2: {
      out: (〈0;#Workflow〉 & {
        _hidden(:p): (〈1;#step〉 & {
          run: "foo bar"
        })
      })
      #Workflow: {}
      #step: matchN(1, [
        {
          run!: _
        },
      ])
    }
  }
}
