Skip to main content
Glama

Roslyn CodeLens MCP Server

MCP Toplist

NuGet NuGet Downloads npm Build Status codecov License Docs GitHub Sponsors

A Roslyn-based MCP server that gives AI agents deep semantic understanding of .NET codebases — type hierarchies, call graphs, DI registrations, diagnostics, refactoring, and more.


Hosted deployment

A hosted deployment is available on Fronteir AI.

Related MCP server: solograph

Features

  • find_implementations — Find all classes/structs implementing an interface or extending a class

  • find_callers — Find every call site for a method, property, or constructor

  • find_event_subscribers — Every += / -= site for an event symbol, with resolved handler and subscribe/unsubscribe tag

  • find_tests_for_symbol — List xUnit/NUnit/MSTest methods that exercise a production symbol; opt-in transitive walk through helpers

  • get_test_summary — Per-project inventory of test methods with framework, attribute kind, data-row count, location, and production symbols referenced

  • find_uncovered_symbols — Public methods and properties no test transitively reaches; sorted by cyclomatic complexity for prioritization

  • generate_test_skeleton — Emit a compilable test-class skeleton (as text) for a method or type. Auto-detects xUnit/NUnit/MSTest; surfaces constructor dependencies as TodoNotes; returns a suggested file path. Closes the loop with find_uncovered_symbols

  • get_type_hierarchy — Walk base classes, interfaces, and derived types

  • get_di_registrations — Scan for DI service registrations. Reads generic (AddSingleton<IFoo, Foo>()), single-generic, typeof pair and factory-lambda forms

  • get_instantiation_options — "How do I construct this type?" in one call: constructors with full parameter detail, static factory methods declared anywhere in the solution (including on a separate factory type), DI registrations, and required members. Pass fromProject to learn whether that project can actually reach each option — it honours InternalsVisibleTo, so it answers "can my test project call this internal constructor?"

  • get_project_dependencies — Get the project reference graph

  • get_symbol_context — One-shot context dump for any type

  • get_public_api_surface — Enumerate every public/protected type and member in production projects; flat, deterministically-sorted list suitable for API review or breaking-change baselines.

  • find_breaking_changes — Diff the current API against a baseline JSON or DLL; report removed members, kind changes, and accessibility changes with Breaking/NonBreaking severity.

  • find_reflection_usage — Detect dynamic/reflection-based usage

  • get_exception_flow — What exceptions can escape a method: walks callees depth-bounded, propagates each throw up through every enclosing try/catch, and reports what still escapes with its propagation path; metadata callees contribute their documented exceptions

  • find_throw_sites — Every place an exception type is thrown, optionally including derived types; rethrows flagged

  • find_catch_blocks — Every catch for a type, optionally via base clauses; flags filtered, rethrowing, and empty (swallowing) handlers

  • find_references — Find all references to any symbol (types, methods, properties, fields, events), each tagged with a kind (read, write, readwrite, invocation, method_group, object_creation, cast, type_check, typeof, base_type, type_constraint, type_argument, declaration, attribute, nameof, xml_doc) and reported per occurrence with a column; filter server-side with kinds (e.g. ["write","readwrite"] for mutation sites)

  • go_to_definition — Find the source file and line where a symbol is defined

  • get_method_source — Full declaration source (XML docs, attributes, signature, body — original formatting) for one or many members by name in a single call: methods (all overloads), constructors, properties, indexers, fields, events; per-item statuses (ok/notFound/ambiguous/metadata/unsupportedKind) so a batch never fails wholesale

  • resolve_stack_trace — Map a pasted .NET stack trace to file/line/symbol, undoing compiler name mangling (async/iterator state machines, lambdas, local functions, generic arity); handles inner-exception chains, log-prefixed lines, and Demystifier traces

  • get_diagnostics — List compiler errors, warnings, and Roslyn analyzer diagnostics

  • get_code_fixes — Get available code fixes with structured text edits for any diagnostic

  • search_symbols — Fuzzy workspace symbol search by name

  • get_nuget_dependencies — List NuGet package references per project

  • find_attribute_usages — Find types and members decorated with a specific attribute

  • find_obsolete_usage — Every [Obsolete] call site grouped by deprecation message and severity, errors first; for planning migrations

  • find_circular_dependencies — Detect cycles in project or namespace dependency graphs

  • check_architecture — Enforce layering rules you supply (forbid and allowOnly) against the real semantic type graph rather than using directives; violations are grouped per boundary with a reference count and example sites

  • get_complexity_metrics — Cyclomatic complexity, cognitive complexity and max nesting depth per member (methods, constructors, properties, indexers, operators). Cyclomatic counts paths and starts at 1; cognitive measures how hard the code is to follow and starts at 0. metric picks which one the threshold and sort use — cognitive is the better refactoring-priority signal, cyclomatic the better test-budget one

  • find_naming_violations — Check .NET naming convention compliance

  • find_async_violations — Sync-over-async, async void misuse, missing awaits, fire-and-forget tasks; per-violation report with severity

  • find_disposable_misuse — IDisposable/IAsyncDisposable instances not wrapped in using/await using/returned/assigned to field; severity error/warning per violation.

  • find_large_classes — Find oversized types by member or line count

  • find_god_objects — Types combining high size with high cross-namespace coupling; sharper signal than raw size for SRP violations

  • find_unused_symbols — Dead code detection via reference analysis. Auto-filters test methods (xUnit/NUnit/MSTest), MCP tool entry points, source-generator output, MEF-composed services, and interop-laid-out fields; filter counts surface in summary.filteredOut

  • get_project_health — Composite audit aggregating 7 quality dimensions per project (complexity, large classes, naming, unused symbols, reflection, async violations, disposable misuse) with counts and top-N hotspots inline

  • get_source_generators — List source generators and their output per project

  • get_generated_code — Inspect generated source code from source generators

  • inspect_external_assembly — Browse types, members, and XML docs from closed-source NuGet packages and referenced assemblies

  • peek_il — Decompile any method to ilasm-style IL bytecode from closed-source or generated assemblies

  • get_code_actions — Discover available refactorings and fixes at any position (extract method, rename, inline variable, and more)

  • apply_code_action — Execute any Roslyn refactoring by title, with preview mode (returns a diff before writing to disk)

  • rename_symbol — Solution-wide safe rename of a type or member via Roslyn's Renamer, with preview mode, conflict reporting, and a freshness check against on-disk edits

  • change_signature — Add, remove, and reorder the parameters of a method or constructor, a positional record's primary constructor included, and rewrite every call site; handles named/optional arguments, params and extension methods, reports the overrides and interface implementations it cascaded to, and warns about record properties, deconstructions and positional patterns the rewrite does not reach

  • list_solutions — List all loaded solutions and which one is currently active

  • set_active_solution — Switch the active solution by partial name (all subsequent tools operate on it)

  • load_solution — Load an additional .sln/.slnx at runtime and make it the active solution

  • unload_solution — Unload a loaded solution to free memory

  • rebuild_solution — Force a full reload of the analyzed solution

  • start_background_task — Queue a long-running tool (currently rebuild_solution) to run in the background; returns a taskId to poll

  • get_task_status — Get the current status, result, or error of a background task by its taskId. Optional waitSeconds (default 0, capped at 50) waits on the server until the task finishes instead of polling

  • list_running_tasks — List background tasks running or completed within the last 5 minutes

  • trust_solution — Authorize a solution to run Roslyn analyzers (required before get_diagnostics with includeAnalyzers: true)

  • list_trusted_paths — Inspect the persistent trust store + session-trusted solutions

  • revoke_trust — Revoke a previously-granted trust for a solution path

  • analyze_data_flow — Variable read/write/capture analysis within a statement range (declared, read, written, always assigned, captured, flows in/out)

  • analyze_control_flow — Branch/loop reachability analysis within a statement range (start/end reachability, return statements, exit points)

  • analyze_change_impact — Show all files, projects, and call sites affected by changing a symbol — combines find_references and find_callers

  • get_type_overview — Compound tool: type context + hierarchy + file diagnostics in one call

  • analyze_method — Compound tool: method signature + callers + outgoing calls in one call

  • get_overloads — Every overload of a method/constructor (source + metadata) with full parameter and modifier detail in one call

  • get_extension_methods — Every extension member applicable to a type — including arrays, nullables and tuples — from the solution and referenced assemblies (so LINQ shows up), using Roslyn's own applicability rules; covers C# 14 extension blocks including properties and static members

  • get_operators — Every user-defined operator and conversion operator on a type (source + metadata) with kind, signature, parameters, and source location. Includes synthesized record equality and .NET 7+ checked variants

  • get_call_graph — Transitive caller/callee graph for a method, depth-bounded with cycle detection

  • get_file_overview — Compound tool: types defined in a file + file-scoped diagnostics in one call

Response shape

All list-returning tools wrap their results in a uniform envelope:

{
  "items": [ ... ],
  "totalCount": 142,
  "truncated": false,
  "limit": 500,
  "summary": { ... }
}

When truncated is true, the items are the top N by the tool's natural sort order (severity-first, worst-first, by-project, etc.) — usually that's exactly what you want. Raise limit only if the missing tail items matter for the task.

Tools that include a summary aggregate today:

  • get_diagnostics — { error, warning, info, hidden } counts

  • find_references — { byProject: { name: count }, byKind: { kind: count } }

  • find_callers, find_attribute_usages — { byProject: { name: count } }

  • search_symbols, find_reflection_usage — { byKind: {...} }

  • find_unused_symbols — { byKind, filteredOut: { testMethod, testContainer, mcpTool, generated, composition, interop } }

  • find_naming_violations — { byRule: {...} }

  • get_complexity_metrics — { max, avg, overThreshold, maxCognitive } (the first three describe the selected metric)

Single-object tools (get_type_overview, get_symbol_context, apply_code_action, etc.) return their bespoke shape directly — the envelope only wraps list-returning tools.

Error responses

When a tool can't proceed (symbol not resolved, solution not trusted, file not found, ambiguous match, etc.), the response is an isError: true content block carrying a structured JSON body:

{
  "code": "SolutionNotTrusted",
  "message": "Solution 'Foo.sln' is not trusted for analyzer execution. ...",
  "details": { "solutionPath": "C:\\Foo.sln" }
}

Error codes (switch on code to handle each):

  • SymbolNotFound — type / method / property could not be resolved.

  • SolutionNotTrusted — get_diagnostics or get_code_fixes requested analyzers but the solution hasn't been authorized via trust_solution.

  • AmbiguousMatch — set_active_solution / unload_solution matched multiple solutions; details.matches lists them.

  • FileNotFound — file path or baseline doesn't exist (or isn't in any loaded project).

  • ProjectNotFound — solution name didn't match any loaded solution.

  • InvalidArgument — caller-supplied input was malformed, unsupported, or out of range.

  • Internal — unexpected error not modeled above; message carries the underlying exception text.

Cancellation: the MCP framework's native cancellation is honored. Cancelling a tools/call request mid-flight terminates the operation; long-running tools (get_diagnostics with analyzers, get_code_actions, apply_code_action, get_code_fixes) check the token at hot-loop boundaries.

External Assemblies

Metadata-origin symbols (from NuGet packages and referenced assemblies) are first-class citizens:

  • Tier 1 — Navigation (find_references, find_callers, find_implementations): Accepts closed-source type and member names. Resolves them from assembly metadata and reports all source-level usage sites.

  • Tier 2 — Inspection (inspect_external_assembly): Browse namespaces, types, members, and XML doc comments from any referenced assembly without decompiling.

  • Tier 3 — IL (peek_il): Decompile a specific method to annotated ilasm-style IL using ICSharpCode.Decompiler — useful for understanding the internals of NuGet libraries.

Location-returning results include an Origin field (source or metadata) and an IsGenerated flag to distinguish hand-written code from closed-source or generated output.

Runtime configuration

  • ROSLYN_CODELENS_OPEN_PROJECT_TIMEOUT_SECONDS — per-project MSBuild load timeout (default 300). When a project exceeds this duration during workspace open, it's recorded as a SkippedProjects entry with kind: "Timeout" and the rest of the solution still loads. Useful when a legacy or malformed project wedges the BuildHost-net472 subprocess.

Security: Trust Model

get_diagnostics and get_code_fixes can load Roslyn analyzers — DLLs that execute in-process. To prevent untrusted analyzers from running automatically, this server uses a VS/Rider-style trust model:

  • Solutions passed on the CLI at startup are auto-trusted for the current session.

  • Other solutions must be explicitly trusted via the trust_solution MCP tool.

  • Analyzer DLLs must come from the user's NuGet global packages folder, the dotnet SDK install dir, or the solution's own bin/obj. Other paths are skipped.

Use the list_trusted_paths and revoke_trust tools to inspect and manage trust state. Persistent trust is stored at %APPDATA%\roslyn-codelens\trust.json.

See SECURITY.md for the full threat model.

Quick Start

npx (any MCP client)

{
  "mcpServers": {
    "roslyn-codelens": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "roslyn-codelens-mcp"]
    }
  }
}

The npm package ships no server code — it is a launcher that installs the RoslynCodeLens.Mcp .NET global tool at a matching version and execs it, so the .NET 10 or 11 SDK must be on PATH. Subsequent starts skip the install entirely and work offline.

VS Code / Visual Studio (via dnx)

Add to your MCP settings (.vscode/mcp.json or VS settings):

{
  "servers": {
    "roslyn-codelens": {
      "type": "stdio",
      "command": "dnx",
      "args": ["RoslynCodeLens.Mcp", "--yes"]
    }
  }
}

Claude Code Plugin

claude install gh:MarcelRoozekrans/roslyn-codelens-mcp

The plugin needs only the .NET 10 or 11 SDK: it runs the server through dnx, pinned to the plugin's version, so there is no global tool to install or keep up to date.

.NET Global Tool

dotnet tool install -g RoslynCodeLens.Mcp

Then add to your MCP client config:

{
  "mcpServers": {
    "roslyn-codelens": {
      "command": "roslyn-codelens-mcp",
      "args": [],
      "transport": "stdio"
    }
  }
}

Docker

Runs without a .NET SDK on the host; the solution is bind-mounted at /workspace.

docker build -t roslyn-codelens-mcp .
docker run -i --rm -v "$PWD:/workspace" roslyn-codelens-mcp

The mounted solution must be restored for MSBuildWorkspace to resolve its references, and tool output reports container paths rather than host paths — see docs/site/docs/getting-started/docker.md.

Usage

The server automatically discovers .sln files by walking up from the current directory. You can also pass one or more solution paths directly:

# Single solution
roslyn-codelens-mcp /path/to/MySolution.sln

# Multiple solutions — switch between them with set_active_solution
roslyn-codelens-mcp /path/to/A.sln /path/to/B.sln

When multiple solutions are loaded, use list_solutions to see what's available and set_active_solution("B") to switch context. The first path is active by default.

HTTP transport

By default the server speaks stdio. Pass --http to expose the same tools over streamable HTTP instead — useful for one long-lived server (warm Roslyn workspace, no per-client startup cost) shared by several local MCP clients:

roslyn-codelens-mcp /path/to/MySolution.sln --http            # http://127.0.0.1:3001
roslyn-codelens-mcp /path/to/MySolution.sln --http --port 8080
{
  "mcpServers": {
    "roslyn-codelens": {
      "type": "http",
      "url": "http://127.0.0.1:3001"
    }
  }
}

The HTTP endpoint binds to 127.0.0.1 only and is intended for single-user, local use: all connected clients share the same solution state (set_active_solution affects everyone), and there is no authentication. --host can widen the binding, but the server will warn — its tools can read and modify source files, so only do this on networks you fully trust.

Performance

All type lookups use pre-built reverse inheritance maps, member indexes, and attribute indexes for O(1) access. Benchmarked on an i9-12900HK with .NET 10.0.7:

Tool

Latency

Memory

go_to_definition

2.1 µs

576 B

find_implementations

2.5 µs

720 B

get_project_dependencies

2.8 µs

1.5 KB

get_type_hierarchy

3.5 µs

1.3 KB

find_circular_dependencies

3.7 µs

2.7 KB

get_symbol_context

4.1 µs

1.0 KB

get_source_generators

16 µs

23 KB

analyze_data_flow

19 µs

1.6 KB

find_attribute_usages

72 µs

904 B

get_generated_code

78 µs

24 KB

analyze_control_flow

115 µs

14 KB

inspect_external_assembly (summary)

159 µs

35 KB

find_large_classes

265 µs

3.5 KB

get_di_registrations

478 µs

16 KB

inspect_external_assembly (namespace)

564 µs

259 KB

find_reflection_usage

705 µs

19 KB

get_complexity_metrics

781 µs

25 KB

get_code_actions

792 µs

54 KB

get_file_overview

797 µs

101 KB

get_diagnostics

822 µs

99 KB

get_nuget_dependencies

849 µs

48 KB

get_public_api_surface

885 µs

247 KB

get_type_overview

1.1 ms

104 KB

peek_il

1.1 ms

34 KB

find_disposable_misuse

3.5 ms

286 KB

find_uncovered_symbols

3.8 ms

224 KB

search_symbols

3.9 ms

557 KB

analyze_method

5.8 ms

333 KB

find_async_violations

7.0 ms

335 KB

find_tests_for_symbol (direct)

8.4 ms

396 KB

find_callers

10 ms

337 KB

find_tests_for_symbol (transitive)

12 ms

399 KB

find_naming_violations

15 ms

788 KB

find_unused_symbols

23 ms

1.0 MB

find_references

28 ms

1013 KB

analyze_change_impact

33 ms

1.3 MB

Solution loading (one-time)

~4.1 s

16 MB

Hot Reload

The server watches .cs, .csproj, .props, and .targets files for changes. When a change is detected, affected projects are lazily re-compiled on the next tool query — only stale projects and their downstream dependents are re-compiled, not the full solution.

Location-returning tools include an IsGenerated flag to distinguish source-generator output from hand-written code.

Requirements

  • .NET 10 or 11 SDK

  • A .NET solution with compilable projects

Project compatibility

The server analyses every project that MSBuildWorkspace can load under the .NET SDK runtime.

Supported: SDK-style projects (<Project Sdk="...">), any target framework — net48, net6.0, net8.0, net10.0, etc. .NET Framework targets work fine as long as the csproj uses the SDK-style format.

Skipped (with a warning, not a crash): legacy non-SDK-style projects (<Project ToolsVersion="..." xmlns="http://schemas.microsoft.com/developer/msbuild/2003">, typically .NET Framework projects authored in older versions of Visual Studio). These rely on Microsoft.Common.props imports from the .NET Framework MSBuild that ships with Visual Studio, which is not available in the .NET SDK MSBuild runtime.

When a solution contains legacy projects, the server:

  1. Loads every SDK-style project normally — all tools work for those.

  2. Skips each legacy project and records it in LoadedSolution.SkippedProjects.

  3. Surfaces the skipped list via list_solutions (the SkippedProjects array on each SolutionInfo) and in the return message of load_solution. Each entry includes the project name, kind (Legacy), and reason.

To analyse a legacy project, convert it to SDK-style format (see Microsoft's migration guide) or open the solution from a Visual Studio Developer Command Prompt so the full Visual Studio MSBuild is on PATH.

Development

dotnet build
dotnet test
dotnet run --project benchmarks/RoslynCodeLens.Benchmarks -c Release

Third-party licenses

Family

Roslyn CodeLens MCP is part of a small family of .NET projects for AI work:

  • AI.Sentinel: Security monitoring middleware for IChatClient: prompt injection, hallucination and PII detection with an audit trail.

  • Minos.NET: Typed, source-generated decision questions with calibrated answers.

  • Rag.NET: A modular retrieval-augmented generation pipeline on Microsoft.Extensions.AI.

  • MemoryLens MCP: On-demand .NET memory profiling with AI-actionable fixes over MCP.

Built on ZeroAlloc

Roslyn CodeLens MCP uses these ZeroAlloc libraries, which are source generators and analyzers with no reflection at runtime:

License

MIT

Available Tools

67 tools
analyze_change_impactA

Analyze the blast radius of changing a symbol — shows every file, project, and call site affected. Combines find_references and find_callers into a single impact summary. Use before renaming, changing signatures, or removing a type/method.

Inputs: symbol (required).

analyze_control_flowA

Analyze control flow within a range of statements in a C# method. Returns reachability of start/end points, return statements, and exit points. Useful for detecting unreachable code and understanding branching.

Inputs: endLine (required), filePath (required), startLine (required).

analyze_data_flowB

Analyze data flow within a range of statements in a C# method. Returns variables declared, read, written, captured by lambdas, and flowing in/out of the region. Useful for understanding variable lifecycle before extracting code.

Inputs: endLine (required), filePath (required), startLine (required).

analyze_methodA

Get a comprehensive analysis of a method in one call: signature, location, all callers, and all outgoing calls (methods this method invokes). More efficient than calling find_callers separately.

Inputs: symbol (required).

apply_code_actionA

Apply a code action (refactoring or fix) by its title. Use get_code_actions first to discover available actions. Defaults to preview mode (returns diff without writing files). Set preview=false to apply changes to disk.

Inputs: line (required), column (required), filePath (required), actionTitle (required), +3 more.

change_signatureA

Add, remove, or reorder a method's parameters and update every call site (Roslyn's own change-signature engine). Cascades to overrides and interface implementations, rewrites named and optional arguments, and preserves an extension method's this parameter; the overrides and implementations it also rewrote are listed in CascadedTo. Operations apply in order: remove drops parameter; reorder takes order, a full permutation of the parameters surviving at that point; add appends name plus type and REQUIRES callSiteValue — the expression every existing call site will pass, since the tool never guesses call-site semantics — with an optional defaultValue that instead makes the parameter optional and leaves existing calls untouched. Rejected as unsafe: an added name that is not a valid C# identifier or collides with an existing parameter; a type that does not resolve, or resolves ambiguously (qualify it); moving or removing an extension method's this parameter (it must stay first); and any signature that would leave a surviving params array anywhere but last — add the parameter and reorder it before the params array, or remove that array. Defaults to preview mode (returns edits without writing files); set preview=false to apply. New compiler errors the change would introduce are reported as Conflicts, and apply mode refuses to write them unless force=true. Source-defined methods only; overloaded names must be disambiguated.

Inputs: method (required), operations (required), force, preview.

check_architectureA

Check user-supplied layering rules against the solution's real semantic type graph (resolved symbols, not using directives — so a fully qualified reference with no using is still caught, and an unused using is not reported). Rule kinds: forbid (a dependency from from to to is a violation) and allowOnly (a dependency from from to anything outside to is a violation). TWO SEMANTICS YOU MUST KNOW TO READ AN EMPTY RESULT CORRECTLY. (1) allowOnly evaluates ONLY solution-internal, non-generated targets: references to framework and NuGet namespaces such as System.Collections.Generic are ignored (otherwise every file would violate every allowOnly rule), and so are types declared entirely in generated code, which the caller cannot remove. To restrict a framework or generated namespace, write an explicit forbid — that path DOES evaluate metadata and generated targets. (2) Self-references are always allowed: a scope depending on itself is never a violation, under either kind. Results are grouped per violated rule plus sourceScope plus targetScope edge, each with a full referenceCount and the first maxSitesPerViolation sites. Sorted by rule order, then by descending reference count. Generated code is never reported as the SOURCE of a violation under either kind. Envelope adds a byRule / totalReferences / rulesEvaluated summary.

Inputs: rules (required), limit, scope, maxSitesPerViolation.

find_async_violationsA

Detect six classes of async/await misuse across all production projects: sync-over-async (.Result, .Wait*, GetAwaiter().GetResult()), async void outside event handlers, missing await in async methods, and fire-and-forget tasks. Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Static analysis only — no fix suggestions.

Inputs: no named parameters.

find_attribute_usagesA

Find all types and members decorated with a specific attribute (e.g., Obsolete, Authorize, Serializable). Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Inputs: attribute (required), limit.

find_breaking_changesA

Diff the current solution's public API surface against a baseline (JSON snapshot from a prior get_public_api_surface run, or a baseline .dll file). Reports five change kinds: Removed/KindChanged/AccessibilityNarrowed (Breaking) plus Added/AccessibilityWidened (NonBreaking). Returns a summary plus a per-change list (kind, severity, fully-qualified name, entity kind, project, file, line, details). Sort: Breaking before NonBreaking, then name ASC. Limitations: return type changes, sealed-ness changes, and nullable annotation changes are not detected (PublicApiEntry schema doesn't capture them).

Inputs: baselinePath (required).

find_callersA

Find every call site for a method. Returns an envelope with items, totalCount, truncated, limit, and a byProject summary.

Inputs: symbol (required), limit.

find_catch_blocksA

Find the catch clauses that handle an exception type across the solution, and say what each one does with it. Each item reports hasFilter (a when clause, so the handler may decline at runtime), rethrows (the body contains a bare throw;) and isEmpty (an empty handler body) — together these answer 'who is silently swallowing this exception?' in a single call. By default only clauses declaring exactly the requested type match; set includeBaseClauses to also surface handlers that catch a base type, including catch (Exception) and bare catch, since those bind the requested type too. caughtType is null for a bare catch. The exception type may live in source or in metadata. Returns an envelope with items, totalCount, truncated, limit and a byType / byProject summary, sorted by file, line, column.

Inputs: exceptionType (required), limit, includeBaseClauses.

find_circular_dependenciesA

Detect circular dependencies in the project reference graph or namespace dependency graph. Returns an envelope with items sorted by cycle length desc, totalCount, truncated, and limit (default 100).

Inputs: level, limit.

find_disposable_misuseA

Detect IDisposable / IAsyncDisposable instances at risk of leaking. Two patterns: local variables holding a disposable that aren't wrapped in using/await using/returned/assigned-to-field-or-out-parameter (warning), and bare-expression-statement discards of a disposable creator/factory (error). Returns a summary plus a per-violation list (severity error/warning, location, containing method, snippet). Skips test projects and generated code. Scope: methods only (not constructors/accessors/operators); ownership transfer via method/constructor argument is not detected. Static analysis only — no fix suggestions.

Inputs: no named parameters.

find_event_subscribersA

Find every += and -= site for an event symbol across the solution. Accepts source events (e.g. 'MyClass.Clicked') or metadata events (e.g. 'System.Diagnostics.Process.Exited'). Each result reports the source location, the resolved handler (method FQN, or a synthetic name like 'lambda at File.cs:N' for inline handlers), and the subscription kind (Subscribe for +=, Unsubscribe for -=). Use this for memory-leak audits (compare subscribe/unsubscribe pairs), UI event subscriber inspection, or when Grep over '+= EventName' would miss qualified or fully-typed subscription sites. Returns an envelope with items sorted by file path then line, totalCount, truncated, and limit (default 500).

Inputs: symbol (required), limit.

find_god_objectsA

Find types that combine high size with high coupling — 'god classes' that violate single-responsibility and become refactoring nightmares. Sharper signal than find_large_classes alone: a 1000-line internal helper used only by its own namespace is not flagged, but a 200-line class called from 15 different namespaces is. Two axes: size (lines/members/fields) and coupling (incoming/outgoing namespace counts). A type qualifies when it crosses ALL THREE size thresholds AND at least one coupling threshold — keeps DTOs (high field count only) and dispatchers (high member count only) off the list. Defaults: lines >= 300, members >= 15, fields >= 10, incoming-namespaces >= 5, outgoing-namespaces >= 5. Each threshold is independently configurable. BCL namespaces (System., Microsoft.) excluded from outgoing count. Test projects, generated code, interfaces, and nested types are skipped. Sort: total axes exceeded DESC, then line count DESC.

Inputs: project, minLines, minFields, minMembers, +2 more.

find_implementationsA

Find all classes/structs implementing an interface or extending a class. Returns an envelope with items, totalCount, truncated, and limit.

Inputs: symbol (required), limit.

find_large_classesA

Find classes and structs that exceed member count or line count thresholds. Returns an envelope with items sorted worst-first (highest size first), totalCount, truncated, and limit (default 100).

Inputs: limit, project, maxLines, maxMembers.

find_naming_violationsA

Check .NET naming convention compliance: PascalCase types/methods/properties, camelCase parameters, I-prefix interfaces, _ prefix private fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byRule summary.

Inputs: limit, project.

find_obsolete_usageA

Find every call site referencing [Obsolete]-marked symbols in the solution, grouped by deprecation message and severity. Sharper than find_attribute_usages for migration-planning workflows: tells you 'we have 5 distinct deprecations pending; this one has 80 sites and is an error; that one has 3 sites and is a warning.' Includes both source-marked and metadata-marked obsoletes (third-party NuGet deprecations are surfaced too). Symbols with zero usages are omitted (no migration needed). Sort: errors first, then by usage count descending, then by symbol name. Test projects skipped. Project filter is case-insensitive.

Inputs: project, errorOnly.

find_referencesA

Find all references to a symbol (type, method, property, field, or event) across the solution, each tagged with a kind. Kinds: read, write, readwrite (compound assignment / ++ / ref), invocation, method_group, object_creation, cast, type_check (is / patterns / as-tests), typeof, base_type, type_constraint, type_argument, declaration, attribute, nameof, xml_doc, and usage (rare fallback). Pass kinds to return only some (e.g. ["write","readwrite"] for mutation sites). Envelope adds a byKind summary. Multiple references on one line are reported separately with a column.

Inputs: symbol (required), kinds, limit.

find_reflection_usageA

Detect dynamic/reflection-based usage like Type.GetType, Activator.CreateInstance, MethodInfo.Invoke. Returns an envelope with items, totalCount, truncated, limit (default 500), and a byKind summary.

Inputs: limit, symbol.

find_tests_for_symbolA

List test methods that exercise the given production symbol. Recognises xUnit, NUnit, and MSTest. Set transitive=true to follow helper methods up to maxDepth levels (default 3, max 5).

Inputs: symbol (required), maxDepth, transitive.

find_throw_sitesA

Find every place an exception type is thrown across the solution — throw new T(...), throw expr; and bare throw; rethrows (whose type comes from the enclosing catch). The exception type may live in source or in metadata, so System.ArgumentNullException works as well as your own MyApp.DomainException. Set includeDerived to also match subclasses of the requested type. Every throw in the file is reported, including throws inside lambdas and local functions, attributed to the member that contains them — use get_exception_flow instead when the question is which exceptions escape a specific method. Returns an envelope with items, totalCount, truncated, limit and a byType / byProject summary, sorted by file, line, column.

Inputs: exceptionType (required), limit, includeDerived.

find_uncovered_symbolsA

Report public methods and properties that no test method transitively reaches (within 3 helper hops). Output sorted by cyclomatic complexity descending, with a coverage summary including a riskHotspotCount (uncovered with complexity >= 5). Recognises xUnit, NUnit, MSTest. Reference-based static analysis — does not parse runtime coverage data.

Inputs: no named parameters.

find_unused_symbolsA

Find potentially unused types and members (dead code detection). Checks public symbols for references across the solution. Filters out test methods, MCP tools, source-generator output, MEF-composed services, and interop-laid-out fields. Returns an envelope with items, totalCount, truncated, limit (default 500), and a summary including byKind + filteredOut counts.

Inputs: limit, project, includeInternal.

generate_test_skeletonA

Emits a test-class skeleton (parseable C#) for a method or type. Pass a type FQN like 'MyApp.Services.OrderService' to get a full test class with one stub per public method, or a method FQN like 'MyApp.Services.OrderService.PlaceOrder' to get a single stub. Returns framework, suggested file path, class name, full file contents (as text), and TodoNotes for things to wire up (e.g. constructor dependencies). The tool does NOT write to disk — agent decides what to do with the text. Pairs naturally with find_uncovered_symbols / get_test_summary. Stubs include happy-path Fact, Theory + InlineData for primitive-param methods, and Assert.Throws assertions per distinct direct-throw exception type. Async (Task-returning) methods detected automatically. Properties, indexers, operators, and constructors are excluded from per-method enumeration. Framework auto-detected from solution test projects (tie → xUnit); override with framework='xunit' / 'nunit' / 'mstest'.

Inputs: symbol (required), framework.

get_call_graphA

Transitive caller and/or callee graph for a method symbol, depth-bounded with cycle detection. Output is an adjacency-list dict per direction (callees and/or callers), where each visited symbol maps to its outgoing edges. Direction: 'callees' (what this method transitively calls), 'callers' (who reaches this method), or 'both'. External (BCL/NuGet) callees appear as terminal leaves with isExternal=true. Declared signature only on callee side — no virtual dispatch resolution; agent uses find_implementations separately if needed. Callers side resolves dispatch naturally via Roslyn SymbolFinder. Hard cap on total visited nodes (default 500) — sets truncated=true if hit; edges to truncated targets are still recorded against the source node. Use this instead of recursive find_callers / analyze_method calls when you need depth > 1.

Inputs: symbol (required), maxDepth, maxNodes, direction.

get_code_actionsA

List available code actions (refactorings and fixes) at a position in a C# file. Optionally specify endLine/endColumn to select a range for extract-method style refactorings. Returns action titles that can be passed to apply_code_action. Returns an envelope with items sorted by kind then title, totalCount, truncated, and limit (default 100).

Inputs: line (required), column (required), filePath (required), limit, +2 more.

get_code_fixesA

Get available code fixes for a specific diagnostic at a file location. Returns structured text edits that can be reviewed and applied. Returns an envelope with items sorted by title, totalCount, truncated, and limit (default 100).

Inputs: line (required), filePath (required), diagnosticId (required), limit.

get_complexity_metricsA

Calculate complexity for members (methods, constructors, properties, indexers, operators). Reports both 'complexity' (cyclomatic - the number of paths, starts at 1) and 'cognitive' (how hard the code is to follow, starts at 0 - a 0 is not a bug), plus 'maxNesting'. The 'metric' parameter selects which of the two the threshold filters on and the sort uses. Returns an envelope with items sorted worst-first, totalCount, truncated, limit (default 100), and a summary with max/avg/overThreshold plus maxCognitive.

Inputs: limit, metric, project, threshold.

get_diagnosticsA

List compiler errors and warnings across the solution, optionally including analyzer diagnostics. Analyzer diagnostics require the solution to be trusted (see 'trust_solution'). Returns an envelope with items, totalCount, truncated, limit, and a severity summary.

Inputs: limit, project, severity, includeAnalyzers.

get_di_registrationsA

Scan IServiceCollection extension methods for DI registrations of a type. Returns an envelope with items sorted by service name, totalCount, truncated, and limit (default 200).

Inputs: symbol (required), limit.

get_exception_flowA

Which exceptions can escape a method — the 'is calling this safe?' question. Walks the method's callees depth-first (cycle-safe, depth- and node-bounded) collecting every explicit throw, then propagates each one back up the call chain, testing the enclosing try/catch at the throw and at every call site on the way out. Each item reports escapes, the path of methods from the analysed method to the one that raises it, and — when it is stopped — caughtIn, caughtFile, caughtLine. A handler with a when filter sets hasFilter and the exception is still reported as escaping, because the filter may decline at runtime. origin is thrown for a real throw site in source, or documented for an exception XML doc tag on a metadata (BCL/NuGet) callee — set includeDocumented to false to drop the latter. Throws inside lambdas and local functions are excluded: they escape when that body runs, not at this method's boundary — use find_throw_sites for a plain textual scan of throws. Static analysis only: no reflection, no virtual-dispatch resolution, and no implicit runtime failures such as null dereferences. Hitting maxDepth or maxNodes sets truncated.

Inputs: method (required), maxDepth, maxNodes, includeDocumented.

get_extension_methodsA

Answer 'what extension members can I call on this type?' — every extension method and C# 14 extension property applicable to a receiver type, from solution source AND referenced metadata (so BCL LINQ such as Where, Select, Chunk is included). Applicability is decided by the compiler's own reduction, not by name matching: this IEnumerable<T> is reported for string (which is IEnumerable<char>) while this IEnumerable<string> is not. Each entry carries the reduced call-site signature (receiver dropped, generic inference applied, return type first: IEnumerable<int> Where<int>(Func<int, bool>), int Tripled), kind (method or property), declaring type, namespace, origin (source or metadata), source file/line for source members, XML doc summary, and isStatic. Read isStatic before writing the call: false means an instance call (value.Doubled()) and is the normal case even though every extension method is DECLARED static; true means a C# 14 static extension member, called on the type itself (int.Zero). Results are NOT filtered by using scope — the tool has no call-site position, so every applicable member is reported and its namespace is given for you to add the import. Pass a type name: simple (Widget), fully qualified (MyApp.Widget), a C# keyword (int, string), a constructed generic (List<int>), an array (string[]), a nullable (int?), or a tuple ((int, string)). Sort: source before metadata, then declaring type, then name.

Inputs: type (required), limit, nameFilter.

get_file_overviewA

Get a summary of a C# file: which types are defined in it and any compiler diagnostics. Useful for quickly understanding a file's contents without reading it. Also accepts .razor/.cshtml markup, resolving it to the C# document its source generator produced.

Inputs: filePath (required).

get_generated_codeB

Inspect generated source code from source generators. Returns an envelope with items sorted by project then file path, totalCount, truncated, and limit (default 200).

Inputs: file, limit, generator.

get_instantiation_optionsA

Answer 'how do I construct this type?' in one call — accessible constructors, static factory methods declared anywhere in the solution, and DI registrations. Constructors report every parameter's type and name, declared accessibility, whether the constructor is compiler-supplied (isImplicit — a struct or a class with no declared constructor still has a usable parameterless one), and whether it is obsolete. Factories are static members returning the type, including ones declared on a DIFFERENT type such as WidgetFactory.Create(), with Task<T>/ValueTask<T> unwrapped and flagged isAsync. Instance builder methods are excluded because the builder itself would need constructing. Pass fromProject to get accessible computed for that project, which honours InternalsVisibleTo — this is how you find out whether your test project can reach an internal constructor. Without it, accessible is null, meaning NOT COMPUTED — which is not the same as false, so do not read a null as 'you cannot call this'. requiredMembers lists members that must be set in an object initializer. diRegistrations shows where the type is registered in a container — a registered type is usually meant to be resolved rather than constructed by hand. For interfaces, abstract classes and static classes, instantiable is false and note explains why; use find_implementations to find concrete types.

Inputs: symbol (required), fromProject.

get_method_sourceA

Return the full declaration source (XML docs, attributes, signature, body — original formatting) of one or more members by name: methods (all overloads returned), constructors (request as Widget.Widget or fully qualified Ns.Widget.Widget; nested types need full qualification), properties, indexers (request as Type.this or Type.this[]), fields, events. Batch-friendly: pass many names in one call instead of reading whole files. Per-item statuses: ok, notFound, ambiguous (with candidates), metadata (use peek_il or inspect_external_assembly), unsupportedKind (whole types — use get_type_overview). Items keep request order.

Inputs: symbols (required), limit.

get_nuget_dependenciesC

List NuGet package references for projects in the solution

Inputs: project.

get_operatorsA

Return every user-defined operator and conversion operator on a type in one call — source AND metadata. Each entry includes the operator kind (such as +, ==, implicit, explicit, plus all comparison and bitwise operators), full signature, parameter names/types/modifiers, return type, accessibility, an IsCheckedVariant flag for .NET 7+ checked operators (op_CheckedAddition etc.), XML doc summary, and source location (empty for metadata). Includes compiler-synthesized record equality operators. Returns declared operators only — operators do not inherit in C#. Pass a type name, simple or fully qualified (e.g. 'Vector2', 'MyApp.Money', 'System.Decimal'). Sort: kind ordinal ASC, then parameter count ASC, then signature ordinal ASC.

Inputs: symbol (required).

get_overloadsA

Return every overload of a method (or constructor) in one call — source AND metadata. Each overload includes the full signature, parameter names/types/modifiers (ref/out/in/params/optional with defaults), return type, accessibility, modifiers (static/virtual/abstract/override/async/extension), generic type parameters, XML doc summary, and source location (empty for metadata). Pass 'Type.Method' for ordinary methods or 'Type.Type' for constructors. Operator overloads are excluded — use get_operators for those. Sort: parameter count ASC, then signature ordinal ASC.

Inputs: symbol (required).

get_project_dependenciesA

Return the project reference graph (direct and transitive dependencies)

Inputs: project (required).

get_project_healthA

Aggregate 7 health dimensions per project in one call: complexity hotspots, large classes, naming violations, unused symbols, reflection usage, async violations, and disposable misuse. Returns counts per dimension plus the top-N hotspots inline (default 5) so the caller can prioritise without follow-up calls. Use this when answering 'how is this project doing?' / 'where should I focus?' / 'what's the technical debt picture?'. Underlying defaults: complexity threshold 10, large-class limits 20 members / 500 lines, unused symbols excludes internals. Test projects are skipped. Project filter is case-insensitive. Sort: projects ASC by name; hotspots sorted by severity proxy per dimension (cyclomatic complexity desc, line count desc, severity enum desc for async/disposable).

Inputs: project, hotspotsPerDimension.

get_public_api_surfaceA

Enumerate every public and protected type and member declared in production projects of the active solution. Returns a deterministically-sorted (name ASC) flat list of API entries (kind, fully-qualified name, accessibility, project, file, line) plus per-kind/per-project/per-accessibility summary buckets. Skips test projects, generated code, compiler-generated members, internal symbols, and protected members on sealed types (unreachable). Inherited members are not repeated under derived types — only declared members appear.

Inputs: no named parameters.

get_source_generatorsA

List source generators and their output per project. Returns an envelope with items sorted by project then generator name, totalCount, truncated, and limit (default 100).

Inputs: limit, project.

get_symbol_contextB

One-shot context dump for a type: namespace, base class, interfaces, injected dependencies, public members

Inputs: symbol (required).

get_task_statusA

Get the current status of a background task by its taskId.

Inputs: taskId (required).

get_test_summaryA

Per-project inventory of test methods. Each test reports framework (xUnit/NUnit/MSTest), attribute kind ([Fact]/[Theory]/[Test]/[TestCase]/[TestMethod]/[DataTestMethod]), data-driven row count, location, and the production symbols it references. Complements find_tests_for_symbol (which goes test → production); this goes project → tests. Use to answer 'what does this test suite cover?' or to break down test counts by framework/attribute. Production projects, generated code, and BCL/framework calls are filtered out of the per-test referenced-symbols list. Project filter is case-insensitive. Sort: tests by (file, line); projects by name ASC.

Inputs: project.

get_type_hierarchyB

Walk up (base classes, interfaces) and down (derived types) from a type

Inputs: symbol (required).

get_type_overviewA

Get a comprehensive overview of a type in one call: full context (namespace, base class, interfaces, members, DI dependencies), type hierarchy (bases, interfaces, derived types), and diagnostics in the file. More efficient than calling get_symbol_context + get_type_hierarchy + get_diagnostics separately.

Inputs: typeName (required).

go_to_definitionA

Find the source file and line where a symbol is defined. Returns an envelope with items, totalCount, truncated, and limit.

Inputs: symbol (required), limit.

inspect_external_assemblyA

Inspect a referenced closed-source assembly. mode='summary' returns namespaces + type counts; mode='namespace' returns public types and members for the given namespace.

Inputs: assemblyName (required), mode, namespaceFilter.

list_running_tasksA

List background tasks that are running or completed within the last 5 minutes.

Inputs: limit.

list_solutionsA

List all solutions loaded by this server, showing which one is currently active. Each entry includes any projects that were skipped during load (e.g. legacy non-SDK-style projects), with the kind and reason for each skip. Returns an envelope with items sorted by solution path, totalCount, truncated, and limit (default 50).

Inputs: limit.

list_trusted_pathsA

Return the current trust state: session-scoped paths, persistent paths, trusted roots, and analyzer policy.

Inputs: no named parameters.

load_solutionA

Load a .sln/.slnx solution at runtime and make it the active solution. Both include and rootProjects match against the project FILE NAME without extension (the .csproj/.vbproj base name), NOT the assembly name. Pass include (case-insensitive glob array, supporting only * and ? wildcards — character classes like [...] are NOT supported) or rootProjects (EXACT, case-sensitive file names) to load only a subset; the loader walks ProjectReference transitively from those seeds to keep the workspace semantically complete. A filter that matches NO project is an ERROR (the call fails) — it does NOT silently fall back to a full load; if unsure of exact names, do a no-filter load first and call list_solutions to discover them. If the same path is already loaded, providing a new filter disposes the previous workspace (replace semantics). If the solution is already loaded with no filter, it simply activates it (~instant). New solutions take ~3 seconds to load and compile. For very large solutions (hundreds of projects) that take minutes to open, pass background: true to return a taskId immediately instead of blocking; poll it with get_task_status until it succeeds (its result carries the loaded/skipped counts). The new solution only becomes active once the background load finishes, so other tools keep working against the current solution meanwhile.

Inputs: path (required), include, background, rootProjects.

peek_ilA

Return ilasm-style IL for a single method in a referenced closed-source assembly. Input must be a fully-qualified method name with parameter types.

Inputs: methodSymbol (required).

rebuild_solutionA

Force a full reload of the analyzed solution — re-opens the .sln, recompiles all projects, and rebuilds all indexes. Use after changing Directory.Build.props, adding/removing NuGet packages, or when diagnostics seem stale.

Inputs: no named parameters.

rename_symbolA

Safely rename a type or member across the entire solution (Roslyn Renamer). Cascades to references, constructors, overrides, nameof, and XML doc crefs. Defaults to preview mode (returns edits without writing files); set preview=false to apply. New compiler errors the rename would introduce are reported as Conflicts, and apply mode refuses to write them unless force=true. Locals/parameters and file renames are not supported.

Inputs: symbol (required), newName (required), force, preview, +3 more.

resolve_stack_traceA

Map a pasted .NET stack trace to file/line/symbol against the loaded solution, undoing compiler name mangling: async/iterator state machines (<M>d__N.MoveNext), lambdas (<>c / <>c__DisplayClass), local functions (g__Name|), generic arity. Handles Exception.ToString() output, log-prefixed lines, inner-exception chains, and Ben.Demystifier-style traces. Frames without 'in file:line' get the declaration site; frames with it keep the exact location. External frames resolve with origin=metadata. Items are in original trace order.

Inputs: stackTrace (required), limit.

revoke_trustA

Remove a previously trusted solution path or trusted root. Removes both session and persistent entries.

Inputs: path (required).

search_symbolsA

Search for types, methods, properties, and fields by name (case-insensitive substring match). Returns an envelope with items sorted by match quality (exact → prefix → substring), totalCount, truncated, limit (default 200), and a byKind summary.

Inputs: query (required), limit.

set_active_solutionA

Switch the active solution. All subsequent tool calls will operate on the selected solution. Use a partial, case-insensitive name (e.g. 'MyProject' matches 'C:/code/MyProject/MyProject.sln'). Returns the full path of the newly active solution.

Inputs: name (required).

start_background_taskA

Queue a long-running tool to run in the background. Returns a taskId; poll with get_task_status. Allowed tools: rebuild_solution.

Inputs: toolName (required).

trust_solutionA

Mark a solution path (or directory root) as trusted for analyzer execution. Required before get_diagnostics will load Roslyn analyzer DLLs from the solution. Always confirm with the user before calling this tool — analyzer DLLs run as in-process code.

Inputs: path (required), scope.

unload_solutionA

Unload a previously loaded solution to free memory. Use a partial, case-insensitive name (e.g. 'DcpCore' matches the full path). If the unloaded solution was active, another loaded solution becomes active. Use this when you're done analyzing a codebase and want to reclaim memory.

Inputs: name (required).

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.8/5.0

    Scored across 67 tools

    Disambiguation4/5

    Most tools are distinct in purpose, but there is some overlap among query tools (e.g., find_references vs find_callers vs analyze_change_impact) and overview tools (get_type_overview vs get_symbol_context). Descriptions clarify the differences, so confusion is unlikely but not impossible.

    Naming Consistency5/5

    All tool names follow a consistent snake_case verb_noun pattern (find_references, get_diagnostics, rename_symbol, change_signature, etc.). The naming is predictable and uniform, making the API easy to navigate.

    Tool Count2/5

    With 67 tools, the server is extremely heavy. Although it covers a broad domain (analysis, refactoring, testing, dependencies), many tools are highly specific and could be consolidated (e.g., multiple find_* analyzers). This exceeds any reasonable threshold for typical usage.

    Completeness5/5

    The tool set provides comprehensive coverage of the code analysis domain: symbol lookup, references, diagnostics, code fixes, refactoring, test generation, architecture checks, dependency graphs, and more. No obvious gaps exist for the stated purpose of deep Roslyn-based analysis.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      B
      maintenance
      A Model Context Protocol (MCP) server providing 62 AI-optimized tools for .NET/C# semantic code analysis, navigation, refactoring, and code generation using Microsoft Roslyn. Built for AI coding agents - provides compiler-accurate code understanding that AI cannot infer from reading source files alone.
      62
      42
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Code intelligence MCP server for Claude Code providing multi-project code graph, semantic search, session history, knowledge base, and web search.
      15
      4
      MIT
    • A
      license
      Not graded
      quality
      B
      maintenance
      A local .NET MCP server for coding agents, providing persistent semantic indexing, typed-graph DI wiring resolution, reduced context, and compiler-backed verification for .NET projects.
      37
      Apache 2.0