Activate F# expression compiler with initial lowering for Seq/List expressions

[Copilot]

The F# expression compiler path existed only as an unregistered skeleton, so F# sessions had no compiler-specific handling for expressions. This change activates that path and adds a small, pure lowering layer so a first subset of F# syntax can be compiled through the existing C# EE.

• Compiler activation

  • Registers Compiler.vsdconfigxml in the F# evaluator project
  • Scopes the compiler component to F# language sessions only
  • Keeps unsupported paths on safe fallback behavior by continuing to throw NotImplementedException

• Pure lowering layer

  • Adds ExpressionLowering.fs as a VS-independent preprocessing module
  • Lowers a narrow F# subset into C#-EE-friendly expressions:
    • identifiers and member access
    • tuple recursion
    • F# indexer syntax (expr.[i])
    • initial Seq.* / List.* module calls

• Compiler delegation

  • Updates ExpressionCompiler.fs to:
    • lower supported expressions before compilation
    • create a C# DkmLanguageExpression
    • delegate CompileExpression / CompileAssignment to the built-in C# EE
  • Leaves GetClrLocalVariableQuery and unsupported expressions on the fallback path

• Coverage and docs

  • Adds focused tests for lowering behavior, including nested module calls and unsupported syntax
  • Updates README to reflect the active compiler path and the current supported lowering scope

Example of the new lowering behavior:

Seq.length (List.map mapping values)

becomes:

Microsoft.FSharp.Collections.SeqModule.Length(
    (Microsoft.FSharp.Collections.ListModule.Map(mapping, values))
)

Original prompt

Expand the existing expression evaluator extension in the majocha/FSharpExpressionEvaluator repository so it becomes a more substantive F#-aware evaluator implementation. The repository currently installs correctly and replaces the evaluator F# uses, but it is only a starting point.

Use Roslyn's Expression Evaluator implementation in dotnet/roslyn (especially under src/ExpressionEvaluator at commit 441caf3eada0c5e6fc26c5b73dee20db7add3afd) as architectural reference material, but do not copy mindlessly. Prefer idiomatic F# where practical, and preserve the extension's existing integration points.

Goals:

• Inspect the current implementation in majocha/FSharpExpressionEvaluator and determine the highest-value next step that meaningfully expands evaluator functionality.
• Use Roslyn's C# and Visual Basic Expression Evaluator structure as reference for architecture, debugger integration points, evaluation contexts, formatting, and result-provider behavior.
• Implement practical improvements in the target repo that move it toward a real F# expression evaluator, while keeping scope realistic for the current codebase.
• Prefer idiomatic F# for new logic and abstractions whenever possible instead of mechanically porting Roslyn C#/VB code.
• Add or update tests/documentation as appropriate so the design and behavior are understandable.

Suggested areas to investigate:

• How the current extension registers and replaces the default F# evaluator.
• Whether the next useful milestone is expression preprocessing/parsing, F#-specific formatting, a minimal evaluation pipeline, better result handling, or debugger-context plumbing.
• Opportunities to factor shared concerns cleanly between any existing C# host/integration layer and F# implementation code.
• Constraints of Visual Studio debugger APIs and where a lightweight but valuable F#-specific behavior can be added now.

Deliverables:

• Code changes in majocha/FSharpExpressionEvaluator implementing the chosen expansion.
• Tests if the repo supports them, otherwise a concise explanation in docs/comments of limitations and next steps.
• A pull request with a clear summary of what was implemented, what Roslyn concepts were borrowed, and what remains out of scope.

Please keep the implementation incremental and practical: improve the project materially without attempting a complete production-grade F# EE in one step.

This pull request was created from Copilot chat.

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.