[hpetriffer]

Summary

Inlay hints for X# in the VS editor: parameter names at call sites and the inferred type of VAR declarations, the way C# shows its inline hints.

VAR b := Box<INT>{nSize: 3, lFixed: TRUE}
VAR e AS Encoding := System.Text.Encoding.UTF8
o:Open(cFile: "a.dbf", lShared: TRUE)

• Off by default, like C#. All hints show while Alt+F1 is held down. The X# Intellisense options turn parameter and type hints on permanently.
• Parameter hints appear only where the argument does not say what it means (a literal, NIL/NULL_*, TRUE/FALSE, Type{...}), and only when exactly one overload fits the call.
• Type hints appear for VAR, FOREACH VAR and FOR VAR when the initializer does not already show the type and the lookup resolves it. Double-clicking a type hint writes the type into the code.
• Hover shows the same text as QuickInfo. The colours come from the C# "Inline Hints" item.
• Only the visible part is computed: the visible lines plus one screen above and below. Scrolling computes the rest.

LanguageService/InlayHints/
├── HintCandidates.cs      # calls and VAR / FOREACH / FOR declarations from the tokens
├── HintRules.cs           # which hints show, and what they say
├── InlayHintComputer.cs   # lookup per candidate in the computed range
├── InlayHintQueue.cs      # one background computation per document, debounced
├── InlayHintRange.cs      # visible range, covered spans, merge on scroll
├── InlayHintTagger.cs     # IntraTextAdornmentTag, Alt+F1
├── InlayHintAdornment.cs  # the hint itself, tooltip, double-click
├── TypeRewrite.cs         # VAR x := ...  ->  LOCAL x := ... AS Type
└── InlayHintTriggers.cs   # settings, Alt+F1, recompute triggers

Changes to shared code that other features use too:

• Lookup: thread-safe state, and the walker pauses while hints are computed. FOREACH VAR now works over a typed array literal, over a VAR local and over <T>{}.

• OverloadFilter:

  • untyped parameters make an implicit CLIPPER method;
  • commas inside type arguments no longer split an argument;
  • Foo<T>(...) and Foo<T>{...} are recognised as calls.

  Find References benefits from all three.

• Find References now finds generic source classes (Box`1) and their constructors.

• Go To Definition: a keyword is no longer a target. This removes the "Cannot navigate to the symbol under the cursor" message after F12 on a creation.

• Code model (XProject.prg, ModelWalker.prg): building a source type no longer looks up the file for each member.

Evidence

• Tests: LanguageService.Tests run 330/330. New test classes:

  • for the hints themselves: HintCandidates, HintRules, InlayHintRange, InlayHintQueue, InlayHintSettings, TypeRewrite and InlayHintColors;
  • LookupThreading and GotoDefinition.

  OverloadFilter, FindReferencesEngine and ReferenceCandidateScanner have new cases.

• Performance:

  • Before: computing the whole file at once and finding call arguments by name made a large file take seconds, and the scan was quadratic.
  • After: a 775 KB file from a large VO code base takes 80–661 ms per screen.
  • ALargeFileIsScannedInLinearTime guards against the quadratic scan; with it put back in, 4× the calls took 23× as long.

• Checked by hand in VS 2022:

  • hints with Alt+F1 and with the options;
  • tooltip, double-click edit and colours;
  • generic calls;
  • F12 and Find References on generic classes.

  The project builds for VS 2019 and VS 2022; only VS 2022 was checked by hand.

Merge Danger

Door: two-way

The hints are off by default, and nothing is stored in the user's code unless they double-click a hint.

Blast Radius: language service

The shared lookup, OverloadFilter, SymbolResolver.ForCreation and the code model changed. A regression there would show in Find References, Go To Definition / Implementation or completion, not only in the hints.

Known limitations (deferred)

• Foo(a < b, c > (d)) is read as type arguments (the same rule as C#).
• A positional keyword used as a name cannot take type arguments.
• A static-style call of an extension method gets no parameter hints.
• Each resolved call still searches the token list twice; this is limited to the computed range.
• Test gaps: the FOREACH lookup itself, the Box → Box`1 resolution, and the tagger's Alt+F1 flow.

🤖 Generated with Claude Code