ttsc 0.19.2 → 0.20.0

package/internal/graph/object_member_signatures_preserve_literal_whitespace_test.go

@@ -0,0 +1,67 @@
+package graph
+
+import (
+  "path/filepath"
+  "testing"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestObjectMemberSignaturesPreserveLiteralWhitespace verifies that compact
+// display text never rewrites whitespace owned by a lexical value.
+//
+// strings.Fields treated quoted and template contents as trivia. It changed
+// string and regular-expression values, and its first-line cut left a multiline
+// template without a closing backtick. The outline may compact surrounding
+// syntax only when the literal itself remains byte-identical and complete.
+//
+//  1. Compile object members with spaced strings, a regexp, and a template.
+//  2. Dump the graph from the Program-owned source snapshot.
+//  3. Assert literal whitespace and the complete template delimiter survive.
+func TestObjectMemberSignaturesPreserveLiteralWhitespace(t *testing.T) {
+  root := t.TempDir()
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  source := `export const shape = {
+  double: "a  b",
+  single: 'c  d',
+  regexp: /e  f/,
+  template: ` + "`left\n  right`" + `,
+};
+`
+  writeFile(t, filepath.Join(root, "src", "main.ts"), source)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  graph := Build(prog)
+  dump, err := NewDump(graph, root, "tsconfig.json", nil, SourceTexts(prog), DumpOrigin{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  signatures := map[string]string{}
+  for _, node := range dump.Nodes {
+    if node.ID != "src/main.ts#shape:variable" {
+      continue
+    }
+    for _, member := range node.ObjectMembers {
+      signatures[member.Name] = member.Signature
+    }
+  }
+  expected := map[string]string{
+    "double":   `double: "a  b"`,
+    "single":   `single: 'c  d'`,
+    "regexp":   `regexp: /e  f/`,
+    "template": "template: `left\n  right`",
+  }
+  for name, want := range expected {
+    if got := signatures[name]; got != want {
+      t.Fatalf("signature for %q = %q, want %q", name, got, want)
+    }
+  }
+}

package/internal/graph/object_members.go

@@ -0,0 +1,229 @@
+package graph
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// collectObjectMembers records the direct, statically named members of the
+// object literal bound by declaration on the variable node Build already owns.
+// The AST is the structure oracle: no source text, brace counter, or regex is
+// involved in deciding which properties belong to the outer object.
+func (g *Graph) collectObjectMembers(path string, declaration *shimast.Node) {
+  if declaration == nil || declaration.Symbol() == nil {
+    return
+  }
+  variable := declaration.AsVariableDeclaration()
+  if variable == nil {
+    return
+  }
+  object := objectLiteralInitializer(variable.Initializer)
+  if object == nil || object.Properties == nil {
+    return
+  }
+  node := g.Nodes[nodeID(path, qualifiedName(declaration.Symbol()), NodeVariable)]
+  if node == nil || node.Pos != declaration.Pos() || node.End != declaration.End() {
+    return
+  }
+  members := make([]ObjectMember, 0, len(object.Properties.Nodes))
+  for _, property := range object.Properties.Nodes {
+    name, kind, ok := objectMemberIdentity(property)
+    if !ok {
+      continue
+    }
+    signatureEnd, signatureBoundary, signatureTokenLen := objectMemberSignatureSpan(property)
+    members = append(members, ObjectMember{
+      Name:              name,
+      Kind:              kind,
+      Pos:               property.Pos(),
+      End:               property.End(),
+      SignatureEnd:      signatureEnd,
+      SignatureBoundary: signatureBoundary,
+      SignatureTokenLen: signatureTokenLen,
+    })
+  }
+  if len(members) > 0 {
+    node.ObjectMembers = members
+  }
+}
+
+// objectMemberSignatureSpan finds the earliest AST boundary after which source
+// belongs to a value body rather than the member outline. It keeps compact
+// scalar initializers such as `real: 1`, but stops before function bodies,
+// arrow expressions, nested object members, and array contents can be copied
+// onto the wire.
+func objectMemberSignatureSpan(property *shimast.Node) (end int, boundary bool, tokenLen int) {
+  end = property.End()
+  candidate, found := sourceBodyBoundary(property)
+  if !found || candidate.end <= property.Pos() || candidate.end > end {
+    return end, false, 0
+  }
+  return candidate.end, true, candidate.tokenLen
+}
+
+type signatureBoundary struct {
+  end      int
+  tokenLen int
+}
+
+func sourceBodyBoundary(node *shimast.Node) (signatureBoundary, bool) {
+  if node == nil {
+    return signatureBoundary{}, false
+  }
+  switch node.Kind {
+  case shimast.KindArrowFunction:
+    arrow := node.AsArrowFunction()
+    if arrow != nil && arrow.EqualsGreaterThanToken != nil {
+      return signatureBoundary{end: arrow.EqualsGreaterThanToken.End()}, true
+    }
+  case shimast.KindBlock, shimast.KindObjectLiteralExpression, shimast.KindArrayLiteralExpression:
+    return signatureBoundary{end: node.Pos(), tokenLen: 1}, true
+  case shimast.KindClassExpression:
+    return signatureBoundary{end: node.Pos(), tokenLen: len("class")}, true
+  }
+
+  var boundary signatureBoundary
+  found := false
+  node.ForEachChild(func(child *shimast.Node) bool {
+    candidate, ok := sourceBodyBoundary(child)
+    if ok {
+      boundary = candidate
+      found = true
+      // ForEachChild visits source order, so the first body boundary is the
+      // earliest and later children cannot improve the outline cut.
+      return true
+    }
+    return false
+  })
+  return boundary, found
+}
+
+// objectLiteralInitializer unwraps the transparent expression wrappers a
+// declaration commonly places around an object literal. None changes which
+// direct properties the literal declares.
+func objectLiteralInitializer(initializer *shimast.Node) *shimast.ObjectLiteralExpression {
+  for initializer != nil {
+    switch initializer.Kind {
+    case shimast.KindObjectLiteralExpression:
+      return initializer.AsObjectLiteralExpression()
+    case shimast.KindAsExpression:
+      expression := initializer.AsAsExpression()
+      if expression == nil {
+        return nil
+      }
+      initializer = expression.Expression
+    case shimast.KindSatisfiesExpression:
+      expression := initializer.AsSatisfiesExpression()
+      if expression == nil {
+        return nil
+      }
+      initializer = expression.Expression
+    case shimast.KindParenthesizedExpression:
+      expression := initializer.AsParenthesizedExpression()
+      if expression == nil {
+        return nil
+      }
+      initializer = expression.Expression
+    case shimast.KindTypeAssertionExpression:
+      expression := initializer.AsTypeAssertion()
+      if expression == nil {
+        return nil
+      }
+      initializer = expression.Expression
+    case shimast.KindNonNullExpression:
+      expression := initializer.AsNonNullExpression()
+      if expression == nil {
+        return nil
+      }
+      initializer = expression.Expression
+    default:
+      return nil
+    }
+  }
+  return nil
+}
+
+// objectMemberIdentity returns the source-visible name and details kind of one
+// direct object-literal property. The boolean distinguishes an unsupported
+// spread or dynamic computed key from the valid static property name `""`.
+func objectMemberIdentity(property *shimast.Node) (string, NodeKind, bool) {
+  if property == nil {
+    return "", "", false
+  }
+  kind := NodeVariable
+  switch property.Kind {
+  case shimast.KindPropertyAssignment, shimast.KindShorthandPropertyAssignment:
+  case shimast.KindMethodDeclaration, shimast.KindGetAccessor, shimast.KindSetAccessor:
+    kind = NodeMethod
+  default:
+    return "", "", false
+  }
+  name, ok := staticObjectMemberName(property.Name())
+  return name, kind, ok
+}
+
+// staticObjectMemberName resolves the declaration forms whose property name is
+// fixed by syntax. A computed literal is fixed; a computed expression is not.
+func staticObjectMemberName(name *shimast.Node) (string, bool) {
+  if name == nil {
+    return "", false
+  }
+  switch name.Kind {
+  case shimast.KindIdentifier:
+    if identifier := name.AsIdentifier(); identifier != nil {
+      return identifier.Text, true
+    }
+  case shimast.KindStringLiteral:
+    if literal := name.AsStringLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindNoSubstitutionTemplateLiteral:
+    if literal := name.AsNoSubstitutionTemplateLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindNumericLiteral:
+    if literal := name.AsNumericLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindBigIntLiteral:
+    if literal := name.AsBigIntLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindComputedPropertyName:
+    computed := name.AsComputedPropertyName()
+    if computed == nil {
+      return "", false
+    }
+    return staticComputedObjectMemberName(computed.Expression)
+  }
+  return "", false
+}
+
+func staticComputedObjectMemberName(expression *shimast.Node) (string, bool) {
+  for expression != nil && expression.Kind == shimast.KindParenthesizedExpression {
+    parenthesized := expression.AsParenthesizedExpression()
+    if parenthesized == nil {
+      return "", false
+    }
+    expression = parenthesized.Expression
+  }
+  if expression == nil {
+    return "", false
+  }
+  switch expression.Kind {
+  case shimast.KindStringLiteral:
+    if literal := expression.AsStringLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindNoSubstitutionTemplateLiteral:
+    if literal := expression.AsNoSubstitutionTemplateLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindNumericLiteral:
+    if literal := expression.AsNumericLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  case shimast.KindBigIntLiteral:
+    if literal := expression.AsBigIntLiteral(); literal != nil {
+      return literal.Text, true
+    }
+  }
+  return "", false
+}

package/internal/graph/provenance.go

@@ -14,7 +14,7 @@ import (
 // field is added, removed, or given a new meaning, independently of the serve
 // envelope's protocol version: a one-shot `ttscgraph dump` written to a file has
 // a schema but never rode the protocol.
-const DumpSchemaVersion = 1
+const DumpSchemaVersion = 6
 
 // The capabilities a snapshot can declare. Each names one class of evidence a
 // consumer may rely on when, and only when, the snapshot lists it.
@@ -119,16 +119,16 @@ type Universe struct {
 // references mean two configs can name the same file, and they are not the same
 // input, so the pair is the unit rather than the bare path.
 type RootFile struct {
-  // Config is the tsconfig that named this root, project-relative.
+  // Config is the tsconfig that named this root, in the dump's path vocabulary.
   Config string `json:"config"`
 
-  // File is the root file, project-relative.
+  // File is the root file, in the dump's path vocabulary.
   File string `json:"file"`
 }
 
 // FileDigest pairs a file with the SHA-256 of its bytes, hex-encoded.
 type FileDigest struct {
-  // File is project-relative.
+  // File uses the dump's path vocabulary.
   File string `json:"file"`
 
   // Digest is the hex-encoded SHA-256 of the file's on-disk bytes.
@@ -159,7 +159,7 @@ type FileDigest struct {
 // Both are digests. Neither is text: the wire never carries a file's bytes, and
 // the field names say digest so that stays true by reading.
 type SourceDigest struct {
-  // File is project-relative.
+  // File uses the dump's path vocabulary.
   File string `json:"file"`
 
   // Checker is the hex-encoded SHA-256 of the text the checker resolved
@@ -180,7 +180,7 @@ type SourceDigest struct {
 // Diagnostic is one compiler diagnostic riding the snapshot that produced the
 // facts. Positions are 1-based, matching what tsgo reports.
 type Diagnostic struct {
-  // File is project-relative.
+  // File uses the dump's path vocabulary.
   File string `json:"file"`
 
   // Line is the 1-based line.
@@ -207,13 +207,14 @@ func Digest(sum [sha256.Size]byte) string { return hex.EncodeToString(sum[:]) }
 // implements.
 func TypescriptVersion() string { return shimcore.Version() }
 
-// NewProvenance assembles the evidence for a snapshot. project relativizes every
-// path; texts maps a source file's absolute path to the text the checker read
-// (as SourceTexts returns it); disk maps a source file's absolute path to the
-// hex digest of its on-disk bytes, and a path absent from it is reported with an
-// empty Disk. configs and roots come from the same capture that produced texts.
+// NewProvenance assembles the evidence for a snapshot while retaining the
+// compiler's physical paths. NewDump projects those paths together with every
+// node, edge, span, and diagnostic through its one cached schema-v6 mapper.
+// texts maps a source file's path to the text the checker read (as SourceTexts
+// returns it); disk maps that path to the hex digest of its on-disk bytes, and
+// a path absent from it is reported with an empty Disk. configs and roots come
+// from the same capture that produced texts.
 func NewProvenance(
-  project string,
   producer Producer,
   capabilities []string,
   configs []FileDigest,
@@ -221,32 +222,31 @@ func NewProvenance(
   texts map[string]string,
   disk map[string]string,
 ) Provenance {
-  ctx := newDumpContext(project, nil)
   sources := make([]SourceDigest, 0, len(texts))
   for path, text := range texts {
     sources = append(sources, SourceDigest{
-      File:    ctx.rel(path),
+      File:    path,
       Checker: Digest(sha256.Sum256([]byte(text))),
       Disk:    disk[path],
     })
   }
   sort.Slice(sources, func(i, j int) bool { return sources[i].File < sources[j].File })
 
-  relConfigs := make([]FileDigest, 0, len(configs))
+  capturedConfigs := make([]FileDigest, 0, len(configs))
   for _, config := range configs {
-    relConfigs = append(relConfigs, FileDigest{File: ctx.rel(config.File), Digest: config.Digest})
+    capturedConfigs = append(capturedConfigs, FileDigest{File: config.File, Digest: config.Digest})
   }
-  sort.Slice(relConfigs, func(i, j int) bool { return relConfigs[i].File < relConfigs[j].File })
+  sort.Slice(capturedConfigs, func(i, j int) bool { return capturedConfigs[i].File < capturedConfigs[j].File })
 
-  relRoots := make([]RootFile, 0, len(roots))
+  capturedRoots := make([]RootFile, 0, len(roots))
   for _, root := range roots {
-    relRoots = append(relRoots, RootFile{Config: ctx.rel(root.Config), File: ctx.rel(root.File)})
+    capturedRoots = append(capturedRoots, RootFile{Config: root.Config, File: root.File})
   }
-  sort.Slice(relRoots, func(i, j int) bool {
-    if relRoots[i].Config != relRoots[j].Config {
-      return relRoots[i].Config < relRoots[j].Config
+  sort.Slice(capturedRoots, func(i, j int) bool {
+    if capturedRoots[i].Config != capturedRoots[j].Config {
+      return capturedRoots[i].Config < capturedRoots[j].Config
     }
-    return relRoots[i].File < relRoots[j].File
+    return capturedRoots[i].File < capturedRoots[j].File
   })
 
   // Copy before sorting: the caller's slice is a shared package-level constant,
@@ -259,26 +259,25 @@ func NewProvenance(
     SchemaVersion: DumpSchemaVersion,
     Capabilities:  declared,
     Producer:      producer,
-    Universe:      Universe{Configs: relConfigs, Roots: relRoots},
+    Universe:      Universe{Configs: capturedConfigs, Roots: capturedRoots},
     Sources:       sources,
   }
 }
 
-// NewDiagnostics projects the resident program's compiler diagnostics onto the
-// wire shape, relativized against project and ordered by file, line, column,
-// then code so a snapshot is byte-stable.
+// NewDiagnostics projects the resident program's compiler diagnostics while
+// retaining physical file identities. NewDump maps and re-sorts them with the
+// rest of the snapshot so every path uses one vocabulary.
 //
 // This is one Program.Diagnostics() call over the already-warm checker rather
 // than a second compile, but it is not free: it forces the semantic check of
 // every file the graph would otherwise only have bound. Callers that do not
 // publish diagnostics should not call it.
-func NewDiagnostics(prog *driver.Program, project string) []Diagnostic {
-  ctx := newDumpContext(project, nil)
+func NewDiagnostics(prog *driver.Program) []Diagnostic {
   raw := prog.Diagnostics()
   out := make([]Diagnostic, 0, len(raw))
   for _, diagnostic := range raw {
     out = append(out, Diagnostic{
-      File:     ctx.rel(diagnostic.File),
+      File:     diagnostic.File,
       Line:     diagnostic.Line,
       Column:   diagnostic.Column,
       Code:     int(diagnostic.Code),
@@ -301,6 +300,65 @@ func NewDiagnostics(prog *driver.Program, project string) []Diagnostic {
   return out
 }
 
+// provenance maps every path-bearing provenance field through the dump's one
+// mapper and sorts on the resulting wire identity.
+func (c *dumpContext) provenance(value Provenance) Provenance {
+  sources := make([]SourceDigest, 0, len(value.Sources))
+  for _, source := range value.Sources {
+    sources = append(sources, SourceDigest{
+      File:    c.rel(source.File),
+      Checker: source.Checker,
+      Disk:    source.Disk,
+    })
+  }
+  sort.Slice(sources, func(i, j int) bool { return sources[i].File < sources[j].File })
+
+  configs := make([]FileDigest, 0, len(value.Universe.Configs))
+  for _, config := range value.Universe.Configs {
+    configs = append(configs, FileDigest{File: c.rel(config.File), Digest: config.Digest})
+  }
+  sort.Slice(configs, func(i, j int) bool { return configs[i].File < configs[j].File })
+
+  roots := make([]RootFile, 0, len(value.Universe.Roots))
+  for _, root := range value.Universe.Roots {
+    roots = append(roots, RootFile{Config: c.rel(root.Config), File: c.rel(root.File)})
+  }
+  sort.Slice(roots, func(i, j int) bool {
+    if roots[i].Config != roots[j].Config {
+      return roots[i].Config < roots[j].Config
+    }
+    return roots[i].File < roots[j].File
+  })
+
+  value.Capabilities = append([]string{}, value.Capabilities...)
+  value.Sources = sources
+  value.Universe = Universe{Configs: configs, Roots: roots}
+  return value
+}
+
+// diagnostics maps and orders compiler findings after they join the dump, not
+// in their constructor, so they cannot drift onto a second path vocabulary.
+func (c *dumpContext) diagnostics(values []Diagnostic) []Diagnostic {
+  out := make([]Diagnostic, 0, len(values))
+  for _, diagnostic := range values {
+    diagnostic.File = c.rel(diagnostic.File)
+    out = append(out, diagnostic)
+  }
+  sort.Slice(out, func(i, j int) bool {
+    if out[i].File != out[j].File {
+      return out[i].File < out[j].File
+    }
+    if out[i].Line != out[j].Line {
+      return out[i].Line < out[j].Line
+    }
+    if out[i].Column != out[j].Column {
+      return out[i].Column < out[j].Column
+    }
+    return out[i].Code < out[j].Code
+  })
+  return out
+}
+
 // diagnosticCategory names a severity the way tsc labels it. The driver
 // distinguishes exactly two, and SeverityError is the zero value, so anything
 // that is not an explicit warning is an error.

package/internal/graph/source_texts_cover_every_resident_program_source_test.go

@@ -0,0 +1,73 @@
+package graph
+
+import (
+  "path/filepath"
+  "strings"
+  "testing"
+
+  shimtspath "github.com/microsoft/typescript-go/shim/tspath"
+
+  "github.com/samchon/ttsc/packages/ttsc/driver"
+)
+
+// TestSourceTextsCoverEveryResidentProgramSource verifies that snapshot
+// evidence includes every class of source the checker loaded.
+//
+// External graph leaves still carry checker-derived facts and spans. Omitting
+// their resident text from the source manifest leaves those facts without the
+// byte identity that the sourceDigests capability promises. Virtual bundled
+// libraries need the same checker digest even though they have no disk digest.
+//
+//  1. Compile a project that calls a function declared by an outside `.d.ts`.
+//  2. Build the graph and capture the resident program's source texts.
+//  3. Assert both the outside declaration and a virtual bundled library are in
+//     the checker-text manifest.
+func TestSourceTextsCoverEveryResidentProgramSource(t *testing.T) {
+  workspace := t.TempDir()
+  root := filepath.Join(workspace, "app")
+  declaration := filepath.Join(workspace, "dependency", "index.d.ts")
+  writeFile(t, filepath.Join(root, "tsconfig.json"), fixtureTSConfig)
+  writeFile(t, filepath.Join(root, "src", "main.ts"), `import { external } from "../../dependency";
+
+export const value = external();
+`)
+  writeFile(t, declaration, `export declare function external(): number;
+`)
+  declaration = shimtspath.ResolvePath(declaration)
+
+  prog, diags, err := driver.LoadProgram(root, "tsconfig.json", driver.LoadProgramOptions{})
+  if err != nil {
+    t.Fatal(err)
+  }
+  if len(diags) != 0 {
+    t.Fatalf("unexpected diagnostics: %v", diags)
+  }
+  defer func() { _ = prog.Close() }()
+
+  built := Build(prog)
+  hasExternalFact := false
+  for _, node := range built.Nodes {
+    if node.External && node.File == declaration {
+      hasExternalFact = true
+      break
+    }
+  }
+  if !hasExternalFact {
+    t.Fatalf("graph has no external fact from %s", declaration)
+  }
+
+  texts := SourceTexts(prog)
+  if got, ok := texts[declaration]; !ok || got != "export declare function external(): number;\n" {
+    t.Fatalf("declaration source text = %q, present %v", got, ok)
+  }
+  hasBundledSource := false
+  for path := range texts {
+    if strings.HasPrefix(path, "bundled:///") {
+      hasBundledSource = true
+      break
+    }
+  }
+  if !hasBundledSource {
+    t.Fatal("source manifest has no virtual bundled library")
+  }
+}

package/internal/graphsymbols/position_helpers_follow_ecma_line_terminators_test.go

@@ -0,0 +1,66 @@
+package graphsymbols
+
+import (
+  "testing"
+  "unicode/utf8"
+
+  "github.com/samchon/ttsc/packages/ttsc/internal/graph"
+  "github.com/samchon/ttsc/packages/ttsc/internal/lspserver"
+)
+
+// TestPositionHelpersFollowECMALineTerminators verifies graph-backed LSP
+// positions use the compiler's LF, CRLF, CR, LS, and PS line boundaries.
+//
+// The old offset-to-position helper counted only LF while its inverse counted
+// CR too, so an editor cursor could map to a graph offset that returned on a
+// different line. The test walks every valid UTF-8 cursor boundary on each
+// logical line, including a surrogate-pair column, and requires a round trip.
+//
+// 1. Build three lines with each ECMAScript terminator.
+// 2. Enumerate every valid cursor boundary before each terminator.
+// 3. Convert each offset to UTF-16 LSP position and back to the same offset.
+func TestPositionHelpersFollowECMALineTerminators(t *testing.T) {
+  cases := []struct {
+    name       string
+    terminator string
+  }{
+    {name: "LF", terminator: "\n"},
+    {name: "CRLF", terminator: "\r\n"},
+    {name: "CR", terminator: "\r"},
+    {name: "LS", terminator: "\u2028"},
+    {name: "PS", terminator: "\u2029"},
+  }
+  for _, tc := range cases {
+    t.Run(tc.name, func(t *testing.T) {
+      text := "alpha😀" + tc.terminator + "beta" + tc.terminator + "gamma"
+      starts := graph.ECMALineStarts(text)
+      if len(starts) != 3 {
+        t.Fatalf("line starts = %v, want three lines", starts)
+      }
+      for line, start := range starts {
+        end := graph.LineEnd(text, starts, line)
+        for offset := start; ; {
+          position := offsetToPosition(text, offset)
+          if position.Line != line {
+            t.Fatalf("offset %d position line = %d, want %d", offset, position.Line, line)
+          }
+          restored, ok := lspPositionToOffset(text, position)
+          if !ok || restored != offset {
+            t.Fatalf("offset %d -> %+v -> (%d, %t), want itself", offset, position, restored, ok)
+          }
+          if offset == end {
+            break
+          }
+          _, size := utf8.DecodeRuneInString(text[offset:])
+          if size == 0 {
+            t.Fatal("unexpected zero-width UTF-8 rune")
+          }
+          offset += size
+        }
+      }
+      if _, ok := lspPositionToOffset(text, lspserver.LSPPosition{Line: len(starts), Character: 0}); ok {
+        t.Fatal("position on a nonexistent source line must not resolve")
+      }
+    })
+  }
+}