Address review: charPosFor null-guard + boundary tests

- charPosFor now returns null for out-of-range lines (lineIdx > newlineOffsets.length)
  and negative columns, matching its 'number | null' return type. Previously it
  silently returned column or source.length in those cases.
- Adds direct unit tests for Source.hbsPosFor / charPosFor covering empty source,
  single-char/newline, exact-newline offsets, column-past-line-end clamping, and
  negative/out-of-range inputs.

Author: johanrd

packages/@glimmer/syntax/lib/source/source.ts

@@ -53,9 +53,11 @@ export class Source {
 
   charPosFor({ line, column }: SourcePosition): number | null {
     const lineIdx = line - 1;
-    const lineStart = this.#lineStartFor(lineIdx);
-    const nextNl = this.#newlineOffsets[lineIdx];
-    const lineEnd = nextNl ?? this.source.length;
+    // Valid lines are [0, newlineOffsets.length]. Anything else has no offset.
+    if (lineIdx < 0 || lineIdx > this.#newlineOffsets.length || column < 0) return null;
+
+    const lineStart = lineIdx === 0 ? 0 : (this.#newlineOffsets[lineIdx - 1] as number) + 1;
+    const lineEnd = this.#newlineOffsets[lineIdx] ?? this.source.length;
     const target = lineStart + column;
 
     if (target <= lineEnd) {

packages/@glimmer/syntax/test/source-boundary-test.ts

@@ -0,0 +1,113 @@
+import { src } from '@glimmer/syntax';
+
+const { test } = QUnit;
+
+QUnit.module('[glimmer-syntax] Source - hbsPosFor / charPosFor boundaries');
+
+test('empty source', (assert) => {
+  const s = new src.Source('');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.strictEqual(s.hbsPosFor(1), null);
+
+  assert.strictEqual(s.charPosFor({ line: 1, column: 0 }), 0);
+  assert.strictEqual(s.charPosFor({ line: 2, column: 0 }), null);
+});
+
+test('single char, no newline', (assert) => {
+  const s = new src.Source('a');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.deepEqual(s.hbsPosFor(1), { line: 1, column: 1 });
+  assert.strictEqual(s.hbsPosFor(2), null);
+
+  assert.strictEqual(s.charPosFor({ line: 1, column: 0 }), 0);
+  assert.strictEqual(s.charPosFor({ line: 1, column: 1 }), 1);
+  assert.strictEqual(s.charPosFor({ line: 2, column: 0 }), null);
+});
+
+test('single newline', (assert) => {
+  const s = new src.Source('\n');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.deepEqual(s.hbsPosFor(1), { line: 2, column: 0 });
+  assert.strictEqual(s.hbsPosFor(2), null);
+
+  assert.strictEqual(s.charPosFor({ line: 1, column: 0 }), 0);
+  assert.strictEqual(s.charPosFor({ line: 2, column: 0 }), 1);
+  assert.strictEqual(s.charPosFor({ line: 3, column: 0 }), null);
+});
+
+test('char then newline', (assert) => {
+  const s = new src.Source('a\n');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.deepEqual(s.hbsPosFor(1), { line: 1, column: 1 });
+  assert.deepEqual(s.hbsPosFor(2), { line: 2, column: 0 });
+  assert.strictEqual(s.hbsPosFor(3), null);
+
+  assert.strictEqual(s.charPosFor({ line: 1, column: 0 }), 0);
+  assert.strictEqual(s.charPosFor({ line: 1, column: 1 }), 1);
+  assert.strictEqual(s.charPosFor({ line: 2, column: 0 }), 2);
+  assert.strictEqual(s.charPosFor({ line: 3, column: 0 }), null);
+});
+
+test('two lines, no trailing newline', (assert) => {
+  const s = new src.Source('a\nb');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.deepEqual(s.hbsPosFor(1), { line: 1, column: 1 });
+  assert.deepEqual(s.hbsPosFor(2), { line: 2, column: 0 });
+  assert.deepEqual(s.hbsPosFor(3), { line: 2, column: 1 });
+  assert.strictEqual(s.hbsPosFor(4), null);
+
+  assert.strictEqual(s.charPosFor({ line: 1, column: 0 }), 0);
+  assert.strictEqual(s.charPosFor({ line: 2, column: 1 }), 3);
+  assert.strictEqual(s.charPosFor({ line: 3, column: 0 }), null);
+});
+
+test('two lines with trailing newline', (assert) => {
+  const s = new src.Source('a\nb\n');
+
+  assert.deepEqual(s.hbsPosFor(0), { line: 1, column: 0 });
+  assert.deepEqual(s.hbsPosFor(3), { line: 2, column: 1 });
+  assert.deepEqual(s.hbsPosFor(4), { line: 3, column: 0 });
+  assert.strictEqual(s.hbsPosFor(5), null);
+
+  assert.strictEqual(s.charPosFor({ line: 3, column: 0 }), 4);
+  assert.strictEqual(s.charPosFor({ line: 4, column: 0 }), null);
+});
+
+test('charPosFor clamps column past line-end to line-end', (assert) => {
+  const s = new src.Source('hello\nworld');
+
+  // line 1 has length 5; column 99 should clamp to the newline offset (5).
+  assert.strictEqual(s.charPosFor({ line: 1, column: 99 }), 5);
+  // line 2 has length 5; column 99 should clamp to source.length (11).
+  assert.strictEqual(s.charPosFor({ line: 2, column: 99 }), 11);
+});
+
+test('charPosFor returns null for negative or out-of-range lines', (assert) => {
+  const s = new src.Source('a\nb\nc');
+
+  assert.strictEqual(s.charPosFor({ line: 0, column: 0 }), null, 'line 0');
+  assert.strictEqual(s.charPosFor({ line: -1, column: 0 }), null, 'negative line');
+  assert.strictEqual(s.charPosFor({ line: 4, column: 0 }), null, 'line past end');
+  assert.strictEqual(s.charPosFor({ line: 1, column: -1 }), null, 'negative column');
+});
+
+test('hbsPosFor returns null for negative or out-of-range offsets', (assert) => {
+  const s = new src.Source('abc');
+
+  assert.strictEqual(s.hbsPosFor(4), null, 'offset past length');
+  assert.strictEqual(s.hbsPosFor(100), null, 'offset far past length');
+});
+
+test('hbsPosFor at exact newline offset points to that line', (assert) => {
+  const s = new src.Source('ab\ncd');
+
+  // Offset 2 *is* the '\n' — it belongs to line 1 at column 2.
+  assert.deepEqual(s.hbsPosFor(2), { line: 1, column: 2 });
+  // Offset 3 is the first char after the newline — line 2, column 0.
+  assert.deepEqual(s.hbsPosFor(3), { line: 2, column: 0 });
+});