Code snippets for F# in Visual Studio (Ctrl+K,Ctrl+X / Ctrl+K,Ctrl+S)

[xperiandri]

Description

F# is the only first-class Visual Studio language with no code-snippet support: Ctrl+K,Ctrl+X
("Insert Snippet") and Ctrl+K,Ctrl+S ("Surround With") do nothing in .fs/.fsx, the Code
Snippets Manager has no F# entry, and there is no .snippet file anywhere in this repository.

This adds the expansion path and a C#-parity catalog on top of it:

• Insert Snippet (Ctrl+K,Ctrl+X), Surround With (Ctrl+K,Ctrl+S), and Tab expansion of a
  snippet shortcut.
• 40 built-in snippets, listed under Tools ▸ Code Snippets Manager as F# ▸ Visual F#.
• Two snippet functions: ClassName() fills the enclosing type name into ctor and equals,
  GenerateMatchCases() generates the cases of the union or enum match is given.

Fixes #1498

Design notes

No Roslyn reuse, because there is no seam. Everything Roslyn has for snippets —
AbstractSnippetCommandHandler, SnippetExpansionClient, ISnippetExpansionLanguageHelper,
AbstractSnippetFunction — is internal under
Microsoft.VisualStudio.LanguageServices.Implementation.Snippets, and no *ExternalAccess*
assembly exposes a snippet or expansion type. So F# writes its own IVsExpansionClient, the way
AutomaticCompletion/BraceCompletionSessionProvider.fs already writes its own brace completion.
Roslyn is the design reference, not a base class.

Modern command handlers, legacy expansion engine. The command args
(InsertSnippetCommandArgs, SurroundWithCommandArgs, the four key args) are public platform types
in Microsoft.VisualStudio.Text.UI, so one MEF ICommandHandler<_> part covers all six commands —
no IOleCommandTarget/VSStd2KCmdID plumbing. It is [<Order(After = PredefinedCompletionNames.CompletionCommandHandler)>] so Tab still commits an open completion list
first, exactly as C# orders it. The expansion itself goes through
IVsExpansionManager/IVsExpansion/IVsExpansionSession, which is the only path Ctrl+K,Ctrl+X
has — Roslyn's newer ISnippetProvider model explicitly does not cover it
(docs/ide/specs/semantic_snippets.md, Non-Goals). No new PackageReference: the COM surface is in
Microsoft.VisualStudio.TextManager.Interop.8.0, already on the compile closure.

Registration is a pkgdef. ProvideLanguageCodeExpansionAttribute does not expose the Package
value that DisplayName resolves against, so it cannot produce a correct Code Snippets Manager
entry on its own; C#, VB, XAML, XML and TypeScript all register by hand. The block goes into the
existing vsintegration/Vsix/RegisterFsharpPackage.pkgdef, reuses the F# language service GUID and
VSPackage.resx ID 100 (already localized in all 13 xlf), and registers 1033 outright rather
than %LCID% — registering both would enumerate every snippet twice on an English VS.

Indentation is ours, not the engine's. The expansion engine inserts snippet text verbatim: the
opening line lands at the insertion column and every later line at the column its template spells,
with the text substituted into $selected$ keeping whatever indentation it had in the buffer. C#
survives that because Roslyn's formatter reflows the result afterwards; F# has no formatter
(Formatting/IndentationService.fs only matches the previous line), so FormatSpan computes the
columns itself. That policy is the part where the mistakes live, so it is a separate module free of
editor types — Snippets/SnippetIndentation.fs, ~50 lines — with the buffer edit as the only thing
left in the client. Every case in SnippetIndentationTests.fs is an insertion that came out wrong
at some point, recorded as the columns the engine left behind and the columns the result should
have. A directive wrapper is its own line kind: #if/#else/#endif and the scoped
#nowarn/#warnon pair read at the left margin whatever they wrap, so unlike async { they do not
take the column of the code they cover — and the code keeps the column it had.

Two things fell out of getting that right and are worth flagging for review:

• tsInsertPos is the range InsertNamedExpansion replaces, so passing it the selection deletes
  the code a SurroundsWith snippet was meant to wrap. The engine reads the selection off the
  IVsTextView it was handed in InvokeInsertionUI to fill $selected$ — which is why the legacy
  ExpansionProvider.OnItemChosen in this repo passes GetCaretPos and nothing else.
• GetFieldSpan "selected" does not answer for that special literal, so the substituted range is
  derived instead: the template says which of its lines holds the field and at what column, and the
  command handler counts the lines the selection covered before the insertion replaces it.

The catalog

Expansion unless marked, S = also SurroundsWith.

• Declarations: module, class, record, du, interface, struct, enum, exn,
  attribute, main
• Members: member, abstract, override, prop, propfull, ctor, equals, iface,
  dispose, ext
• Control flow: if S, ife S, match, matcho, matchvo, matchr, matcht, for S,
  forr S, while S, try S, tryf S, use, lock S, #if S (pp_if.snippet, as C# names it),
  nowarn S
• Computation expressions and misc: async S, task S, seq S, pfn

Dropped from the C# set with no F# analogue: checked, unchecked, unsafe, invoke, iterator,
iterindex, indexer, sim/svm (covered by main), mbox, cw (covered by pfn), ~,
pp_region (F# has no #region), and namespace/foreach/do/else, which are one keyword each
in F#.

Deliberate constraints on the files, all enforced by the catalog test:

• <Code> bodies are authored at column 0 with 4-space relative indentation — absolute indentation
  is applied at insertion time, so the file is the truth. (C#'s files carry ad-hoc hard tabs because
  the formatter normalizes them afterwards.)
• Every snippet carries an explicit $end$. That is what removes the need to read the snippet XML
  back out of the live session, and with it the need for Roslyn's re-declared
  IVsExpansionSessionInternal that exists solely to dodge an access violation in GetSnippetNode
  on second invocation.
• $selected$ sits alone on its own line in every SurroundsWith snippet, which is what makes the
  column arithmetic exact.
• The four match* variants are plain literals rather than GenerateMatchCases() calls: their case
  sets are known, so they cost nothing at insertion time and work even when the function falls back.

Tests

vsintegration/tests/FSharp.Editor.Tests/Snippets/:

• SnippetCatalogTests.fs — 242 cases over the shipped files: schema, unique shortcuts and titles,
  shortcut matches the filename, every $literal$ declared and every declaration used, explicit
  $end$, $selected$ present exactly in the SurroundsWith snippets and alone on its line, no
  tabs, the $selected$ layout the expansion client reads back out of each file at insertion time,
  and — the one that keeps "insert a snippet, the file still compiles" honest — every body
  expanded at its defaults parses in one of four hosts (whole file, module level, type body,
  function body).
• SnippetIndentationTests.fs — 14 cases over the column arithmetic described above, and over which
  snippet lines count as directives.

The snippet files are copied next to the test binary the way the VSIX lays them out beside
FSharp.Editor.dll, so the tests run against the shipping layout.

Beyond the unit tests, this code was deployed to the experimental hive and exercised by hand — Insert Snippet, Surround With over code-level and directive wrappers, and the Code Snippets
Manager registration. Every case in SnippetIndentationTests.fs is a column recorded from those
runs. A FSharp.Editor.IntegrationTests case driving the keybindings would be a natural follow-up.

Not in scope

In rough priority order, in rough priority order: snippet shortcuts as IntelliSense completion items (C# does
this; note for whoever picks it up that IVsExpansionEnumeration.Next must be called on the UI
thread — its IDL declares rgelt as out, so a background-thread marshal nulls the buffer),
localized snippet folders under %LCID%, <Imports>/<References> support, SimpleTypeName(), and
snippets for test methods.

Checklist

• Test cases added
• Performance benchmarks added in case of performance changes — not applicable: no existing path changes; the two snippet functions run only when a snippet that declares them is inserted
• Release notes entry updated (docs/release-notes/.VisualStudio/18.vNext.md)

🤖 Generated with Claude Code

[github-actions]

❗ Release notes required

You can open this PR in browser to add release notes: open in github.dev

---

✅ Found changes and release notes in following paths:

Change path	Release notes path	Description
`vsintegration/src`	docs/release-notes/.VisualStudio/18.vNext.md

[xperiandri]

[github-actions]

🔍 Tooling Safety Check — Affects-Build-Infra, Affects-Design-Time, Affects-Test-Tooling
Affects-Build-Infra: Changes VSIX targets and packaged build content.
Affects-Design-Time: Adds editor services executing inside Visual Studio.
Affects-Test-Tooling: Changes test content-copy and compilation configuration.

Generated by PR Tooling Safety Check · gpt56 1.3M · ◷