`nx_lsp_gate.nx` source

↩ module page · 573 lines · 25971 B
1// ============================================================================================
2// nx_lsp_gate.nx -- the referee for LN11 (nx_lsp, the NishiLang language server).
3//
4// WHAT IT PROVES, and why each half is load-bearing:
5//   A CLEAN document must publish ZERO diagnostics and a BROKEN one must publish exactly ONE at the
6//   right line and column. Either half alone is trivially passable: a server that always reports an
7//   error passes the broken case, and a server that never reports one passes the clean case. Only
8//   the PAIR discriminates, so the pairing is a gv_bite cell and not two independent teeth.
9//
10//   The UTF-16 column is checked against a byte column that is DIFFERENT, on a line built at runtime
11//   with multi-byte characters before the offending name. A server that passed byte columns through
12//   would satisfy "character is a plausible number" and fail this. That is the anti-vacuity tooth.
13//
14//   The transcript is a REAL client: a recorded byte stream fed to `nx_lsp serve` on stdin with
15//   stdout captured. Nothing is stubbed, and the framing validator re-derives every Content-Length
16//   from the bytes that followed it -- an escaping bug that shortens a body cannot hide behind a
17//   self-consistent header.
18//
19// DELIBERATE DUPLICATION, DECLARED: this gate carries its OWN substring search, its OWN JSON string
20// escaper and its OWN UTF-16 counter. That is not the duplicate-ruler defect -- it is the opposite.
21// A test that measures the subject with the subject's own helpers cannot catch a defect IN those
22// helpers, and the escaper and the column arithmetic are exactly where the interesting defects live.
23//
24// FIXTURES ARE ASSEMBLED AT RUNTIME in /tmp/nx_lsp_gate/ -- never checked in, never shared with a
25// production beat, and never written into the estate's own source tree where a detector that scans
26// sources would find this gate's own bad input and report it as a real defect. The multi-byte
27// characters are CONSTRUCTED FROM BYTES rather than written as literals: a source file crosses
28// several transports before it reaches a compiler and each of them can re-encode a literal.
29// license_tier: ORIGINAL   No hardware writes (Rule 26).
30// ============================================================================================
31
32import "nx_syscalls.nx"
33import "nx_gate_verdict.nx"
34
35const GL_LF:      i64 = 10
36const GL_CR:      i64 = 13
37const GL_QUOTE:   i64 = 34
38const GL_D0:      i64 = 48
39const GL_D9:      i64 = 57
40const GL_BSLASH:  i64 = 92
41const GL_B10:     i64 = 10
42const GL_WORD:    i64 = 8
43const GL_U8_2:    i64 = 192
44const GL_U8_3:    i64 = 224
45const GL_U8_4:    i64 = 240
46// The two bytes of U+00E9 in UTF-8. Named so the fixture's intent survives any transport.
47const GL_E9_HI:   i64 = 195
48const GL_E9_LO:   i64 = 169
49const GL_LBRACE:  i64 = 123
50const GL_RBRACE:  i64 = 125
51const GL_RBRACK:  i64 = 93
52const GL_MINUS:   i64 = 45
53const GL_ESC_N:   i64 = 110
54const GL_ESC_R:   i64 = 114
55const GL_ESC_T:   i64 = 116
56const GL_TAB:     i64 = 9
57const GL_SEPLEN:  i64 = 4
58const GL_DIAGS_KEYLEN: i64 = 15
59// Scratch sizes for THIS gate's own buffers. Fixtures are a few hundred bytes and the capture is a
60// handful of LSP frames; these are generous by orders of magnitude and every writer is bounded.
61const GL_BUF:     i64 = 262144
62const GL_PATH:    i64 = 1024
63const GL_SMALL:   i64 = 4096
64
65func gl_len(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } return n }
66
67func gl_find(b: *u8, n: i64, start: i64, pat: *u8) -> i64 {
  let pl: i64 = gl_len(pat)
  if pl == 0 { return 0 - 1 }
  var i: i64 = start
  if i < 0 { i = 0 }
  while i + pl <= n {
      var j: i64 = 0
      var ok: i64 = 1
      while j < pl {
          if b[i + j] != pat[j] { ok = 0; j = pl } else { j = j + 1 }
      }
      if ok == 1 { return i }
      i = i + 1
  }
  return 0 - 1
82}
83
84func gl_count(b: *u8, n: i64, pat: *u8) -> i64 {
  var c: i64 = 0
  var at: i64 = 0
  var run: i64 = 1
  while run == 1 {
      let f: i64 = gl_find(b, n, at, pat)
      if f < 0 { run = 0 } else { c = c + 1; at = f + 1 }
  }
  return c
93}
94
95// first decimal integer following `key` at/after `start`; -1 when the key is absent.
96func gl_int_after(b: *u8, n: i64, start: i64, key: *u8) -> i64 {
  let at: i64 = gl_find(b, n, start, key)
  if at < 0 { return 0 - 1 }
  var p: i64 = at + gl_len(key)
  var neg: i64 = 0
  if p < n { if b[p] == (GL_MINUS as u8) { neg = 1; p = p + 1 } }
  var v: i64 = 0
  var got: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if p >= n { run = 0 } else {
          let c: i64 = b[p] as i64
          if c < GL_D0 { run = 0 } else {
          if c > GL_D9 { run = 0 } else { v = v * GL_B10 + (c - GL_D0); got = got + 1; p = p + 1 } }
      }
  }
  if got == 0 { return 0 - 1 }
  if neg == 1 { return 0 - v }
  return v
115}
116
117// THE GATE'S OWN UTF-16 COUNTER. Independent of the subject's, on purpose.
118func gl_u16(b: *u8, n: i64, upto: i64) -> i64 {
  var u: i64 = 0
  var i: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if i >= upto { run = 0 } else {
          if i >= n { run = 0 } else {
              let c: i64 = b[i] as i64
              var adv: i64 = 1
              var units: i64 = 1
              if c >= GL_U8_4 { adv = 4; units = 2 } else {
              if c >= GL_U8_3 { adv = 3 } else {
              if c >= GL_U8_2 { adv = 2 } } }
              u = u + units
              i = i + adv
          }
      }
  }
  return u
137}
138
139func gl_write_file(path: *u8, buf: *u8, n: i64) -> i64 {
  let fd: i64 = sys_openat_wr(path, MODE_0644)
  if fd < 0 { return 0 - 1 }
  var off: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if off >= n { run = 0 } else {
          let w: i64 = sys_write(fd, ((buf as i64) + off) as *u8, n - off)
          if w <= 0 { run = 0 } else { off = off + w }
      }
  }
  sys_close(fd)
  if off != n { return 0 - 1 }
  return 0
153}
154
155func gl_exists(path: *u8) -> i64 {
  let fd: i64 = sys_openat_rd(path)
  if fd < 0 { return 0 }
  sys_close(fd)
  return 1
160}
161
162// THE GATE'S OWN JSON STRING ESCAPER (client side).
163func gl_jesc(d: *u8, o: i64, s: *u8, n: i64) -> i64 {
  var p: i64 = o
  var i: i64 = 0
  while i < n {
      let c: i64 = s[i] as i64
      if c == GL_QUOTE { d[p] = GL_BSLASH as u8; p = p + 1; d[p] = GL_QUOTE as u8; p = p + 1 } else {
      if c == GL_BSLASH { d[p] = GL_BSLASH as u8; p = p + 1; d[p] = GL_BSLASH as u8; p = p + 1 } else {
      if c == GL_LF { d[p] = GL_BSLASH as u8; p = p + 1; d[p] = GL_ESC_N as u8; p = p + 1 } else {
      if c == GL_CR { d[p] = GL_BSLASH as u8; p = p + 1; d[p] = GL_ESC_R as u8; p = p + 1 } else {
      if c == GL_TAB { d[p] = GL_BSLASH as u8; p = p + 1; d[p] = GL_ESC_T as u8; p = p + 1 } else {
          d[p] = s[i]; p = p + 1
      } } } } }
      i = i + 1
  }
  return p
178}
179
180// Content-Length framing, written the way a real client writes it.
181func gl_frame(d: *u8, o: i64, body: *u8, bn: i64) -> i64 {
  var p: i64 = gv_cat(d, o, "Content-Length: " as *u8)
  p = gv_catn(d, p, bn)
  d[p] = GL_CR as u8; p = p + 1
  d[p] = GL_LF as u8; p = p + 1
  d[p] = GL_CR as u8; p = p + 1
  d[p] = GL_LF as u8; p = p + 1
  var i: i64 = 0
  while i < bn { d[p] = body[i]; p = p + 1; i = i + 1 }
  return p
191}
192
193func gl_spawn(elf: *u8, argv: *i64, in_path: *u8, out_path: *u8) -> i64 {
  let pid: i64 = sys_fork()
  if pid < 0 { return 0 - 1 }
  if pid == 0 {
      if (in_path as i64) != 0 {
          let ifd: i64 = sys_openat_rd(in_path)
          if ifd >= 0 { sys_dup3(ifd, 0, 0); sys_close(ifd) }
      }
      if (out_path as i64) != 0 {
          let ofd: i64 = sys_openat_wr(out_path, MODE_0644)
          if ofd >= 0 { sys_dup3(ofd, 1, 0); sys_close(ofd) }
      }
      let envp: *i64 = sys_mmap(GL_WORD * 2) as *i64
      envp[0] = 0
      sys_execve(elf, argv, envp)
      sys_exit(127)
  }
  let st: *i64 = sys_mmap(GL_WORD * 2) as *i64
  st[0] = 0
  sys_wait4(pid, st, 0)
  return wait_status_rc(st[0])
214}
215
216func gl_slurp(path: *u8, len_out: *i64) -> *u8 {
  len_out[0] = 0
  let b: *u8 = sys_read_file(path, len_out)
  if (b as i64) == 0 { len_out[0] = 0 }
  return b
221}
222
223// EVERY Content-Length in the capture must be followed by exactly that many body bytes, and the next
224// thing after a body must be another header or end-of-stream. Returns the frame count, or -1 when
225// the framing does not hold. A self-consistent-but-wrong length is precisely what an escaping bug
226// produces, so re-deriving from the bytes is the only check worth having.
227func gl_frames_valid(b: *u8, n: i64) -> i64 {
  var pos: i64 = 0
  var frames: i64 = 0
  var run: i64 = 1
  while run == 1 {
      if pos >= n { run = 0 } else {
          let at: i64 = gl_find(b, n, pos, "Content-Length: " as *u8)
          if at != pos { run = 0; frames = 0 - 1 } else {
              let clen: i64 = gl_int_after(b, n, pos, "Content-Length: " as *u8)
              if clen <= 0 { run = 0; frames = 0 - 1 } else {
                  let sep: i64 = gl_find(b, n, pos, "\r\n\r\n" as *u8)
                  if sep < 0 { run = 0; frames = 0 - 1 } else {
                      let bs: i64 = sep + GL_SEPLEN
                      if bs + clen > n { run = 0; frames = 0 - 1 } else {
                          var okb: i64 = 1
                          if b[bs] != (GL_LBRACE as u8) { okb = 0 }
                          if b[bs + clen - 1] != (GL_RBRACE as u8) { okb = 0 }
                          if okb == 0 { run = 0; frames = 0 - 1 } else {
                              frames = frames + 1
                              pos = bs + clen
                          }
                      }
                  }
              }
          }
      }
  }
  return frames
255}
256
257func main() -> i64 {
  let ctr: *i64 = gv_ctr()
  gv_head("nx_lsp_gate -- LN11: LSP initialize plus a diagnostics round-trip against a recorded client transcript, with goto-definition and hover over the compiler's own code graph" as *u8)
260
  // ---- SETUP. Scratch is /tmp/<gate>/, created here: a teardown does not run when a run crashes,
  // ---- and a gate that shares a fixture with a production beat measures the beat, not the code.
  let dir: *u8 = sys_mmap(GL_PATH)
  dir[gv_cat(dir, 0, "/tmp/nx_lsp_gate" as *u8)] = 0 as u8
  sys_mkdir(dir, MODE_0755)
266
  let p_helper: *u8 = sys_mmap(GL_PATH)
  let p_ok: *u8    = sys_mmap(GL_PATH)
  let p_bad: *u8   = sys_mmap(GL_PATH)
  let p_u16: *u8   = sys_mmap(GL_PATH)
  let p_tr: *u8    = sys_mmap(GL_PATH)
  let p_cap: *u8   = sys_mmap(GL_PATH)
  let p_out: *u8   = sys_mmap(GL_PATH)
  p_helper[gv_cat(p_helper, 0, "/tmp/nx_lsp_gate/helper.nx" as *u8)] = 0 as u8
  p_ok[gv_cat(p_ok, 0, "/tmp/nx_lsp_gate/main_ok.nx" as *u8)] = 0 as u8
  p_bad[gv_cat(p_bad, 0, "/tmp/nx_lsp_gate/main_bad.nx" as *u8)] = 0 as u8
  p_u16[gv_cat(p_u16, 0, "/tmp/nx_lsp_gate/main_u16.nx" as *u8)] = 0 as u8
  p_tr[gv_cat(p_tr, 0, "/tmp/nx_lsp_gate/client.transcript" as *u8)] = 0 as u8
  p_cap[gv_cat(p_cap, 0, "/tmp/nx_lsp_gate/server.capture" as *u8)] = 0 as u8
  p_out[gv_cat(p_out, 0, "/tmp/nx_lsp_gate/oneshot.out" as *u8)] = 0 as u8
281
  // SUBJECT RESOLUTION, PRINTED NOT ASSUMED. Runners fork _offc/, /api/promote writes the serving
  // root, and a mutation bite refreshes both -- so prefer the twin the runners use and fall back to
  // the promoted binary. Either way the path is on the record: a gate that does not say WHICH
  // binary it measured cannot be re-run against the same subject by the next reader.
  let elf: *u8 = sys_mmap(GL_PATH)
  elf[gv_cat(elf, 0, "_offc/nx_lsp.elf" as *u8)] = 0 as u8
  if gl_exists(elf) == 0 { elf[gv_cat(elf, 0, "nx_lsp.elf" as *u8)] = 0 as u8 }
  gv_puts("  subject: " as *u8) gv_puts(elf) gv_puts("\n" as *u8)
290
  // ---- FIXTURES, assembled here so no bad input is ever a checked-in source byte.
  let fx: *u8 = sys_mmap(GL_BUF)
  let fn: i64 = gv_cat(fx, 0, "func helper_add(a: i64, b: i64) -> i64 {\n    return a + b\n}\n" as *u8)
  gl_write_file(p_helper, fx, fn)
295
  let ok_txt: *u8 = sys_mmap(GL_BUF)
  let ok_n: i64 = gv_cat(ok_txt, 0, "import \"helper.nx\"\nfunc main() -> i64 {\n    let x: i64 = helper_add(1, 2)\n    return x\n}\n" as *u8)
  ok_txt[ok_n] = 0 as u8
  gl_write_file(p_ok, ok_txt, ok_n)
300
  let bad_txt: *u8 = sys_mmap(GL_BUF)
  let bad_n: i64 = gv_cat(bad_txt, 0, "import \"helper.nx\"\nfunc main() -> i64 {\n    let x: i64 = helper_addd(1, 2)\n    return x\n}\n" as *u8)
  bad_txt[bad_n] = 0 as u8
  gl_write_file(p_bad, bad_txt, bad_n)
305
  // ONE LINE, with three two-byte characters before the undefined name, so the UTF-16 column and
  // the byte column are provably different numbers. Bytes, not literals -- see the header.
  let u16_txt: *u8 = sys_mmap(GL_BUF)
  var un0: i64 = gv_cat(u16_txt, 0, "func main() -> i64 { let s: *u8 = \"" as *u8)
  var e: i64 = 0
  while e < 3 {
      u16_txt[un0] = GL_E9_HI as u8; un0 = un0 + 1
      u16_txt[un0] = GL_E9_LO as u8; un0 = un0 + 1
      e = e + 1
  }
  let u16_n: i64 = gv_cat(u16_txt, un0, "\" return zzz(1) }\n" as *u8)
  u16_txt[u16_n] = 0 as u8
  gl_write_file(p_u16, u16_txt, u16_n)
319
  var setup_ok: i64 = 0
  if gl_exists(p_helper) == 1 { if gl_exists(p_ok) == 1 { if gl_exists(p_bad) == 1 {
  if gl_exists(p_u16) == 1 { setup_ok = 1 } } } }
  gv_need("fixtures written to /tmp/nx_lsp_gate" as *u8, setup_ok, ctr)
  gv_need("subject binary _offc/nx_lsp.elf is present" as *u8, gl_exists(elf), ctr)
325
  // ---- expected positions, DERIVED from the fixture bytes rather than written down.
  let bad_line: i64 = 2
  let bad_at: i64 = gl_find(bad_txt, bad_n, 0, "helper_addd" as *u8)
  var bad_ls: i64 = 0
  var q: i64 = 0
  while q < bad_at { if bad_txt[q] == (GL_LF as u8) { bad_ls = q + 1 } q = q + 1 }
  let bad_col_bytes: i64 = bad_at - bad_ls
  let bad_name_len: i64 = gl_len("helper_addd" as *u8)
334
  let u16_at: i64 = gl_find(u16_txt, u16_n, 0, "zzz" as *u8)
  let u16_expect: i64 = gl_u16(u16_txt, u16_n, u16_at)
337
  let ok_at: i64 = gl_find(ok_txt, ok_n, 0, "helper_add(1" as *u8)
  var ok_ls: i64 = 0
  q = 0
  while q < ok_at { if ok_txt[q] == (GL_LF as u8) { ok_ls = q + 1 } q = q + 1 }
  let ok_col: i64 = ok_at - ok_ls
343
  gv_puts("  derived: bad_line0=" as *u8) gv_num(bad_line)
  gv_puts(" bad_col_bytes=" as *u8) gv_num(bad_col_bytes)
  gv_puts(" u16_byte_col=" as *u8) gv_num(u16_at)
  gv_puts(" u16_expect=" as *u8) gv_num(u16_expect)
  gv_puts(" def_col=" as *u8) gv_num(ok_col)
  gv_puts("\n" as *u8)
350
  // ---- ONE-SHOT DIAGNOSTICS -----------------------------------------------------------------
  let argv3: *i64 = sys_mmap(GL_WORD * 8) as *i64
  let a_diag: *u8 = sys_mmap(GL_SMALL)
  a_diag[gv_cat(a_diag, 0, "diag" as *u8)] = 0 as u8
  let a_syms: *u8 = sys_mmap(GL_SMALL)
  a_syms[gv_cat(a_syms, 0, "symbols" as *u8)] = 0 as u8
  let a_serve: *u8 = sys_mmap(GL_SMALL)
  a_serve[gv_cat(a_serve, 0, "serve" as *u8)] = 0 as u8
359
  let lenp: *i64 = sys_mmap(GL_WORD * 2) as *i64
361
  argv3[0] = elf as i64
  argv3[1] = a_diag as i64
  argv3[2] = p_ok as i64
  argv3[3] = 0
  gl_spawn(elf, argv3, 0 as *u8, p_out)
  let cb: *u8 = gl_slurp(p_out, lenp)
  let cn: i64 = lenp[0]
  let clean_diags: i64 = gl_count(cb, cn, "\"severity\":" as *u8)
370
  argv3[2] = p_bad as i64
  gl_spawn(elf, argv3, 0 as *u8, p_out)
  let bb: *u8 = gl_slurp(p_out, lenp)
  let bn2: i64 = lenp[0]
  let bad_diags: i64 = gl_count(bb, bn2, "\"severity\":" as *u8)
  let bad_start: i64 = gl_find(bb, bn2, 0, "\"start\":" as *u8)
  var got_line: i64 = 0 - 1
  var got_char: i64 = 0 - 1
  if bad_start >= 0 {
      got_line = gl_int_after(bb, bn2, bad_start, "\"line\":" as *u8)
      got_char = gl_int_after(bb, bn2, bad_start, "\"character\":" as *u8)
  }
  let msg_names_it: i64 = gl_find(bb, bn2, 0, "helper_addd" as *u8)
384
  gv_puts("  measured: clean_diags=" as *u8) gv_num(clean_diags)
  gv_puts(" bad_diags=" as *u8) gv_num(bad_diags)
  gv_puts(" line=" as *u8) gv_num(got_line)
  gv_puts(" character=" as *u8) gv_num(got_char)
  gv_puts("\n" as *u8)
390
  var bad_fires: i64 = 0
  if bad_diags == 1 { bad_fires = 1 }
  gv_bite("neg-control-clean-document-silent-and-broken-document-fires (either half alone is passable by a server that always, or never, reports an error)" as *u8, bad_fires, clean_diags, ctr)
394
  var line_ok: i64 = 0
  if got_line == bad_line { line_ok = 1 }
  gv_check("T1 the diagnostic lands on the offending line, mapped back through the compiler LineMap from the import-expanded unit" as *u8, line_ok, ctr)
398
  var col_ok: i64 = 0
  if got_char >= bad_col_bytes { if got_char <= bad_col_bytes + bad_name_len { col_ok = 1 } }
  gv_check("T2 the diagnostic column falls inside the offending identifier, derived from the caret the compiler drew" as *u8, col_ok, ctr)
402
  var msg_ok: i64 = 0
  if msg_names_it >= 0 { msg_ok = 1 }
  gv_check("T3 the published message is the compiler's own text and names the offending symbol" as *u8, msg_ok, ctr)
406
  var one_ok: i64 = 0
  if bad_diags == 1 { one_ok = 1 }
  gv_check("T4 exactly ONE diagnostic for one error -- an import-expanded unit must not attribute the imported file's contents to this document" as *u8, one_ok, ctr)
410
  // ---- UTF-16 COLUMN -------------------------------------------------------------------------
  argv3[2] = p_u16 as i64
  gl_spawn(elf, argv3, 0 as *u8, p_out)
  let ub: *u8 = gl_slurp(p_out, lenp)
  let un: i64 = lenp[0]
  let u_start: i64 = gl_find(ub, un, 0, "\"start\":" as *u8)
  var u_char: i64 = 0 - 1
  if u_start >= 0 { u_char = gl_int_after(ub, un, u_start, "\"character\":" as *u8) }
  gv_puts("  measured: utf16_character=" as *u8) gv_num(u_char)
  gv_puts(" byte_column=" as *u8) gv_num(u16_at)
  gv_puts(" expected_utf16=" as *u8) gv_num(u16_expect)
  gv_puts("\n" as *u8)
423
  var u_ok: i64 = 0
  if u_char == u16_expect { u_ok = 1 }
  gv_check("T5 the published character is the UTF-16 code-unit column LSP requires" as *u8, u_ok, ctr)
427
  var u_not_bytes: i64 = 0
  if u16_expect < u16_at { if u_char != u16_at { u_not_bytes = 1 } }
  gv_check("neg-control-utf16-column-is-not-the-byte-column (three two-byte characters precede the name, so a server passing bytes through cannot satisfy this)" as *u8, u_not_bytes, ctr)
431
  // ---- THE RECORDED CLIENT TRANSCRIPT --------------------------------------------------------
  let tr: *u8 = sys_mmap(GL_BUF)
  let bodyb: *u8 = sys_mmap(GL_BUF)
  var t: i64 = 0
  var bo: i64 = 0
437
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"initialize\",\"params\":{\"processId\":null,\"capabilities\":{}}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
440
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"method\":\"initialized\",\"params\":{}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
443
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"method\":\"textDocument/didOpen\",\"params\":{\"textDocument\":{\"uri\":\"file:///tmp/nx_lsp_gate/main_ok.nx\",\"languageId\":\"nishi\",\"version\":1,\"text\":\"" as *u8)
  bo = gl_jesc(bodyb, bo, ok_txt, ok_n)
  bo = gv_cat(bodyb, bo, "\"}}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
448
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"id\":2,\"method\":\"textDocument/definition\",\"params\":{\"textDocument\":{\"uri\":\"file:///tmp/nx_lsp_gate/main_ok.nx\"},\"position\":{\"line\":2,\"character\":" as *u8)
  bo = gv_catn(bodyb, bo, ok_col)
  bo = gv_cat(bodyb, bo, "}}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
453
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"id\":3,\"method\":\"textDocument/hover\",\"params\":{\"textDocument\":{\"uri\":\"file:///tmp/nx_lsp_gate/main_ok.nx\"},\"position\":{\"line\":2,\"character\":" as *u8)
  bo = gv_catn(bodyb, bo, ok_col)
  bo = gv_cat(bodyb, bo, "}}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
458
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"id\":9,\"method\":\"textDocument/completion\",\"params\":{}}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
461
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"id\":4,\"method\":\"shutdown\",\"params\":null}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
464
  bo = gv_cat(bodyb, 0, "{\"jsonrpc\":\"2.0\",\"method\":\"exit\",\"params\":null}" as *u8)
  t = gl_frame(tr, t, bodyb, bo)
467
  gl_write_file(p_tr, tr, t)
469
  argv3[1] = a_serve as i64
  argv3[2] = 0
  let srv_rc: i64 = gl_spawn(elf, argv3, p_tr, p_cap)
  let sb: *u8 = gl_slurp(p_cap, lenp)
  let sn: i64 = lenp[0]
  let frames: i64 = gl_frames_valid(sb, sn)
476
  gv_puts("  measured: transcript_bytes=" as *u8) gv_num(t)
  gv_puts(" capture_bytes=" as *u8) gv_num(sn)
  gv_puts(" frames=" as *u8) gv_num(frames)
  gv_puts(" server_exit=" as *u8) gv_num(srv_rc)
  gv_puts("\n" as *u8)
482
  // BIND EVERY AGGREGATE ASSERTION TO ITS DENOMINATOR. Zero answered frames is not a pass.
  gv_subjects("LSP frames the server actually emitted" as *u8, frames, ctr)
485
  var frame_ok: i64 = 0
  if frames > 0 { frame_ok = 1 }
  gv_check("T6 every Content-Length in the capture is followed by exactly that many bytes of a complete JSON object, re-derived from the bytes rather than trusted" as *u8, frame_ok, ctr)
489
  var init_ok: i64 = 0
  if gl_find(sb, sn, 0, "\"textDocumentSync\":1" as *u8) >= 0 {
  if gl_find(sb, sn, 0, "\"definitionProvider\":true" as *u8) >= 0 {
  if gl_find(sb, sn, 0, "\"hoverProvider\":true" as *u8) >= 0 { init_ok = 1 } } }
  gv_check("T7 initialize returns ServerCapabilities advertising exactly the three surfaces this server implements" as *u8, init_ok, ctr)
495
  var no_lies: i64 = 1
  if gl_find(sb, sn, 0, "completionProvider" as *u8) >= 0 { no_lies = 0 }
  if gl_find(sb, sn, 0, "renameProvider" as *u8) >= 0 { no_lies = 0 }
  if gl_find(sb, sn, 0, "documentSymbolProvider" as *u8) >= 0 { no_lies = 0 }
  if gl_find(sb, sn, 0, "referencesProvider" as *u8) >= 0 { no_lies = 0 }
  gv_check("neg-control-initialize-advertises-nothing-it-does-not-implement (a client greys out its own fallback on a false capability, so the user gets silence instead of a feature)" as *u8, no_lies, ctr)
502
  var pub_ok: i64 = 0
  if gl_find(sb, sn, 0, "\"method\":\"textDocument/publishDiagnostics\"" as *u8) >= 0 {
      if gl_find(sb, sn, 0, "main_ok.nx" as *u8) >= 0 { pub_ok = 1 }
  }
  gv_check("T8 didOpen drove an unsolicited publishDiagnostics for the opened document -- the round trip this rung names" as *u8, pub_ok, ctr)
508
  let pub_at: i64 = gl_find(sb, sn, 0, "\"diagnostics\":[" as *u8)
  var pub_empty: i64 = 0
  if pub_at >= 0 {
      if sb[pub_at + GL_DIAGS_KEYLEN] == (GL_RBRACK as u8) { pub_empty = 1 }
  }
  gv_check("T9 the clean document that IMPORTS A SIBLING publishes an EMPTY diagnostic list -- proving the dirty-buffer shadow resolves the same import set a real build would" as *u8, pub_empty, ctr)
515
  var def_ok: i64 = 0
  let def_at: i64 = gl_find(sb, sn, 0, "\"id\":2" as *u8)
  if def_at >= 0 {
      if gl_find(sb, sn, def_at, "helper.nx" as *u8) >= 0 { def_ok = 1 }
  }
  gv_check("T10 goto-definition resolved ACROSS A FILE BOUNDARY to the declaring file, over the LineMap the compiler itself built" as *u8, def_ok, ctr)
522
  var hov_ok: i64 = 0
  let hov_at: i64 = gl_find(sb, sn, 0, "\"id\":3" as *u8)
  if hov_at >= 0 {
      if gl_find(sb, sn, hov_at, "helper_add" as *u8) >= 0 { hov_ok = 1 }
  }
  gv_check("T11 hover returned the declaration of the symbol under the cursor" as *u8, hov_ok, ctr)
529
  var unknown_ok: i64 = 0
  let unk_at: i64 = gl_find(sb, sn, 0, "\"id\":9" as *u8)
  if unk_at >= 0 {
      if gl_find(sb, sn, unk_at, "-32601" as *u8) >= 0 { unknown_ok = 1 }
  }
  gv_check("neg-control-an-unimplemented-request-is-answered-with-an-error-not-a-fabricated-result" as *u8, unknown_ok, ctr)
536
  var shut_ok: i64 = 0
  if srv_rc == 0 {
      if gl_find(sb, sn, 0, "\"id\":4,\"result\":null" as *u8) >= 0 { shut_ok = 1 }
  }
  gv_check("T12 shutdown then exit leaves the process at LSP exit code 0 -- exit without a prior shutdown must be 1, so the code carries the handshake" as *u8, shut_ok, ctr)
542
  var no_shadow_leak: i64 = 1
  if gl_find(sb, sn, 0, ".nxlsp" as *u8) >= 0 { no_shadow_leak = 0 }
  gv_check("neg-control-no-shadow-path-reaches-the-client (a Location under the dirty-buffer shadow would open a file the user does not have)" as *u8, no_shadow_leak, ctr)
546
  // ---- THE SYMBOL INDEX ARTIFACT -------------------------------------------------------------
  argv3[1] = a_syms as i64
  argv3[2] = p_ok as i64
  argv3[3] = 0
  gl_spawn(elf, argv3, 0 as *u8, p_out)
  let yb: *u8 = gl_slurp(p_out, lenp)
  let yn: i64 = lenp[0]
  let nsyms: i64 = gl_int_after(yb, yn, 0, "syms=" as *u8)
  let cov: i64 = gl_int_after(yb, yn, 0, "coverage_complete=" as *u8)
  let unmapped: i64 = gl_int_after(yb, yn, 0, "unmapped=" as *u8)
  gv_puts("  measured: syms=" as *u8) gv_num(nsyms)
  gv_puts(" unmapped=" as *u8) gv_num(unmapped)
  gv_puts(" coverage_complete=" as *u8) gv_num(cov)
  gv_puts("\n" as *u8)
561
  var cov_ok: i64 = 0
  if cov == 1 { if nsyms > 0 { cov_ok = 1 } }
  gv_check("T13 the symbol index declares complete coverage AND a non-zero population -- a coverage flag over an empty index is the empty-set pass" as *u8, cov_ok, ctr)
565
  var xfile_ok: i64 = 0
  if gl_find(yb, yn, 0, "helper_add" as *u8) >= 0 {
      if gl_find(yb, yn, 0, "helper.nx" as *u8) >= 0 { xfile_ok = 1 }
  }
  gv_check("T14 the index carries the imported file's declarations with THEIR OWN path and line, not the expanded unit's" as *u8, xfile_ok, ctr)
571
  return gv_verdict("LSP-GATE" as *u8, ctr, "LN11 language server" as *u8)
573}
nx_lsp_gate.nx source

`nx_lsp_gate.nx` source
