[hpetriffer]

Summary

Quick actions (light bulb) for X# in the VS editor, the way C# offers them:

Foo(1)                    -> USING Namespace            (fix, when Foo is a type in another namespace)
SELF:Test(n)              -> Generate method 'Test' in class 'Bar'
on the class header       -> Generate overrides...      (dialog with the overridable base members)
ACCESS Name / ASSIGN Name -> Convert to property
                             Convert all ACCESS/ASSIGN in class 'Bar' to properties

• Add USING: offered for a name that does not resolve when a type of that name exists in another namespace (project, referenced projects and assemblies). The USING goes after the existing ones.
• Generate method: for SELF:Foo(), bare calls in a class method and oVar:Foo() on a variable typed as a source class, also when the class is in another file (it is opened). It is offered with the caret on the name, inside the argument list or after the closing parenthesis.

  • The return type comes from the call site, like C#:

    Call	Generated
    o:Foo() as a statement	AS VOID, body RETURN
    IF o:Foo(), WHILE, CASE, UNTIL, .AND./.OR./.NOT.	AS LOGIC
    LOCAL n := o:Foo() AS INT	AS INT
    nCount := o:Foo(), SELF:nCount := ...	declared type of nCount
    RETURN o:Foo()	return type of the enclosing member
    anything else	USUAL (OBJECT in Core)

  • A method with a result throws System.NotImplementedException{} until it is written. Parameter names come from the arguments, types from typed arguments.

  • Not offered for names that exist in the class or a base class, classes with NoMethod, SUPER calls, chains, DLL or late-bound receivers, known functions/defines and compiler pseudo functions (PCount, _Args, ...).

• Generate overrides...: on the class header or a blank line between members. A VO-dialect class can override every method, other dialects virtual/abstract/override members. Members already overridden are skipped, also against DLL bases. Abstract members throw NotImplementedException instead of calling SUPER.
• Convert to property: on the header of an ACCESS or ASSIGN, for the pair or for all convertible pairs of the class in one undo step.
  • One-line GET expr SET expr when both bodies are a single expression, else GET/SET blocks. The ASSIGN parameter becomes VALUE; the wider visibility goes on the property, the narrower on its accessor.
  • Only offered when the conversion does not change behaviour: not for classes without END CLASS, names a base class has, a pair split across files, differing types/index parameters/modifiers, attributes, a CLASS clause, preprocessor lines inside a member.

LanguageService/LightBulb/QuickActions/
├── QuickActionsProvider.cs   # light-bulb source; caret from Caret.PositionChanged, offers cached per version and position
├── QuickActionContext.cs     # enclosing class, name, receiver, arguments, result use - computed in the background
├── QuickActions.cs           # the actions themselves (insert, open the target file, move the caret)
├── UsingCandidates.cs / UsingInserter.cs
├── GenerateMethodRule.cs / MethodSkeleton.cs / CallResult.cs
├── OverrideCandidates.cs / OverrideSkeleton.cs / OverrideTrigger.cs / OverridesDlg.cs
├── PropertyRule.cs / PropertyConverter.cs / AccessorBody.cs / PropertyEdit.cs / ConvertToPropertyAction.cs
└── CodeStyle.cs              # dialect, keyword case, indentation of the generated code

Only new files plus their entries in both LanguageService project files; no existing code changes.

Evidence

• Tests: LanguageService.Tests run 356/356 after merging current dev. New test classes in LanguageService.Tests/QuickActions/: Using, GenerateMethodRule, MethodSkeleton, CallResult, Override, OverrideTrigger, PropertyRule, PropertyConverter, AccessorBody, PropertyEdit and ConvertToProperty.
• Checked by hand in VS 2022 (experimental instance): Add USING, Generate method (return types, caret inside and after the parentheses, target in another file), Generate overrides and Convert to property on a VO and a Core test project. Fixes from that check are in 115dc2f, a4d6791 and ffad58b.
• The project builds for VS 2019 and VS 2022; only VS 2022 was checked by hand.

Merge Danger

Door: two-way

The actions only change code when the user picks one, and each is one undo step.

Blast Radius: language service

A new light-bulb source; it runs the lookup in the background on caret moves (paused code-model walker, result cached per text version and caret position). An error there would show as a missing or wrong light bulb, not in other features.

The branch was tested against both orders with #2164 (inlay hints): it merges with that branch and with current dev without conflicts.

Known limitations

• A call used as an argument (Bar(o:Foo())) gets USUAL/OBJECT, not the parameter type of Bar; that needs the overload resolution of [VS] Inlay hints: parameter names and VAR types #2164.
• With the caret on an identifier passed as an argument (o:Foo(nValue)), the actions are for nValue, not for Foo.

🤖 Generated with Claude Code