Fix/typespec and alias chain resolution

[JesseHerrick]

Summary

Five fixes across the parser, the index-side tokenizer, and the LSP's rename/references paths. Two of them lost work silently: a module rename that left call sites pointing at a module that no longer existed, and a tokenizer misread that dropped everything below a line from the index.

IndexVersion goes to 16 (new reference kind, alias resolution change, tokenizer fix). Existing indexes rebuild on next start.

Rename missed call sites reached through an alias injected by use

A module whose __using__ block declares alias MyApp.Repo puts that short name in the scope of every module that uses it, so those files write Repo.insert(...) with no alias line of their own. The index holds such a site under the bare Repo, which a lookup for MyApp.Repo cannot see — so renaming the module rewrote the use lines and left every one of those calls behind.

The injecting module is found from the renamed module's own references: the alias line inside a __using__ body is itself an indexed reference. So discovery is a couple of small indexed queries rather than statting every __using__ in the project, and a rename that injects nothing pays essentially nothing. Aliases injected through an ExUnit.CaseTemplate (using do rather than defmacro __using__) are included — that is how test files reach theirs, and it was the difference between 669 and 935 references below.

Go-to-references now finds these call sites for a function too. For a module the existing convention is kept: it answers with the alias/import/use sites that name the module, not with every call made through it.

Measured on a 1,484-file / 108k-reference project:

	before	after
rename sites	694	1,368
bare Repo. left in code	624	0
references to that module	249	935 (3ms → 9ms)
references to any other module or function	—	identical count and timing

The remaining mentions of the old name after the rename are comments, docstrings and test names.

Everything after #{flag?} fell out of the index

A predicate name inside a string interpolation ends in ?, which also opens a char literal in Elixir (?a). The tokenizer read the ? of

IO.puts("Backfilling (DRY RUN: #{dry_run?})...")

the second way, so it swallowed the interpolation's closing brace and scanned the whole rest of the file as string content. Every definition and reference below that line was silently missing from the index. One real file was indexed to line 86 of 240+, which is why its Repo.insert! calls survived even the fixed rename.

A ? straight after a name now ends that name; a char literal in operand position still tokenizes as one.

Renaming a with clause's argument renamed the wrong binding

with {:ok, site} <- normalize(site),      # binding A
     {:ok, site} <- authorize(site) do    # A on the right, B on the left

A clause's expression is evaluated before that clause's own pattern binds, so the site inside authorize(...) names binding A. Renaming it reached forward into the second pattern, the later ^site pin and the do block — all of which belong to B.

The occurrences of a clause's binding now stop at the next pattern that binds the name anew. Two related cases fell out of the same fix: a pinned pattern ({:ok, ^site} <-) binds nothing, so it and the body still follow the earlier binding; and a pin in the first clause names the outer binding, which previously returned no occurrences at all.

Typespec mentions counted as calls

A module reference written in a typespec — Ecto.Schema.schema() in @spec put_meta(Ecto.Schema.schema(), meta) — names a type but was indexed as a call, so it turned up in find-references for the macro of that name and drove go-to-definition and hover. Typespec references now carry their own kind: a function lookup drops them, a type lookup keeps only them, and inside a typespec definition and hover prefer the type while outside one they prefer the function.

Alongside it: functions win over same-named types outside a typespec (Ecto.Schema declares both @type schema and defmacro schema/2); private namesakes are no longer offered as definition targets when the call site sits outside the defining module and a public namesake exists.

Aliases built on other aliases

alias SharedLib.Accounts followed by alias Accounts.Users, alias Accounts.{Tokens, Roles} or require Accounts.Macros, as: M kept the short prefix instead of resolving to the canonical module, so definition, hover and references missed the target. The leading segment of an alias/require line is now expanded through the aliases already in scope, in both the index parser and the open-document parser. A require Mod, as: Name inside a quote do block is also kept, so modules that use the injector can resolve the short name.

---

Note

Medium Risk
Large changes to indexing, rename, and reference resolution affect core LSP behavior project-wide; IndexVersion 17 forces a full rebuild, but extensive tests cover the new edge cases.

Overview
This release (0.7.2, IndexVersion 17) tightens Elixir LSP indexing and navigation across the tokenizer, index parser, and server rename/references/definition/hover paths.

Indexing & parsing: Predicate names ending in ? inside #{...} no longer break tokenization and drop the rest of the file. Module refs in @type/@spec/@callback are indexed as typespec (not call), with shared ScanTypespecEnd boundaries. Alias/require lines resolve through ExpandAliasPrefix (chained aliases and require …, as: in __using__ bodies).

Navigation: Go-to-definition/hover pick function vs type from cursor context (InTypespec), drop private namesakes for remote/imported calls when a public match exists, and references filter by typespec vs call. Same-file bare type uses merge with indexed refs; type parameters still use the variable scan.

Rename & references: Module rename and find-references now include call sites that only see a module through a use-injected alias (Repo.all with no local alias), with lexical pairing of use sites, dispatch targets (:controller vs :plain), and column-scoped edits; ExUnit.CaseTemplate injectors are included via LookupCaseTemplateModules.

Rename (variables): with clause occurrences respect evaluation order (RHS uses the previous binding; rebinding stops at the next pattern; pins handled correctly).

^{Reviewed by Cursor Bugbot for commit 03aa65f. Bugbot is set up for automated code reviews on this repo. Configure here.}

[cursor]

Stale Bugbot comment from a previous run.

[cursor]

Stale Bugbot comment from a previous run.

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, have a team admin enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 4c8b400. Configure here.}