JetBrains/resharper-fsharp
42.0
Weak · 13 November 2026
71.2k
lines of production code
F#
with C#, Kotlin
6
measurements over time
What this system is
Features
Add F\# AI Core support for syntax checking, file summarization, and chat context
This change introduces the F\# implementation for the AI Core infrastructure, enabling IDE features like Junie-flavored AI summarization and code assistance for F\# files. It adds FSharpBackendSyntaxErrorChecker to provide backend syntax diagnostics, FSharpFileSummarizer to generate structured summaries of F\# code elements (types, modules, bindings, etc.) for AI context, and FSharpModuleLanguageDetailsProvider to identify F\# modules for chat context providers.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/AICore · high confidence
Add F\# file templates and scope providers
The F\# plugin now includes built-in file templates for creating new F\# source files, signature files, scripts, and types. This change introduces the necessary scope providers (InFSharpProjectScope, InFSharpFile) and UI configuration to make these templates available in the IDE's 'Add New File' dialog for F\# projects.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/FileTemplates · high confidence
Add intention to disable F\# compiler warnings
The F\# plugin now provides a quick-fix intention that allows users to disable specific F\# compiler warnings directly from the code editor. This new action, available via the bulb menu, generates the appropriate \#nowarn directive in the source file to suppress the selected warning, enhancing the developer experience for managing F\# build diagnostics.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/DisableWarning · high confidence
Added F\# lexer implementation for Rider
The F\# lexer source file (\_FSharpLexer.flex) has been added to the rider-fsharp/lexer module. This file contains the Java-based lexer implementation generated from the flex specification, including logic for handling raw interpolated strings, nested comments, and token state management. This change provides the core lexical analysis component required for F\# syntax highlighting and parsing within the Rider IDE.
rider-fsharp/lexer · high confidence
Adds F\# block and line comment handling and doc-comment completion support
The F\# plugin now provides native support for block comments (delimited by (\* and \*)) and line comments (//), including correct insertion logic and availability checks. Additionally, code completion inside XML documentation comments is enabled, allowing users to receive suggestions when editing doc comments.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Comment · high confidence
Color assistance for MonoGame Color type
The F\# plugin now provides color assistance for the MonoGame \Color\ type. This is implemented via a new \FSharpVisualElementFactory\ that recognizes color references created through property access (e.g., \Color.Red\), static factory methods like \FromArgb\ or \FromName\, and constructor invocations, enabling correct syntax highlighting for these specific patterns.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Util · high confidence
Enable AI documentation generation for F\# declarations
The F\# plugin now supports AI-driven documentation generation (DocGen) for F\# code. This change introduces the necessary infrastructure components within the AI features module: a zone marker to register the F\# plugin with the Artificial Intelligence zone, a factory to create code set nodes for F\# declarations, and a support provider that handles the logic for detecting applicable declarations, calculating context, and inserting generated XML documentation comments into the source code.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/AI · high confidence
Enhanced QuickDoc support for F\# compile-time constants and erased types
The F\# QuickDoc provider now displays specific tooltips for compile-time keyword constants such as \_\_SOURCE\DIRECTORY\\, \\_SOURCE\FILE\\, and \\LINE\\_, showing their resolved values (e.g., the source file path or line number) directly in the documentation tooltip. Additionally, the provider has been updated to show quick documentation for erased provided types, ensuring that users can access help for these dynamically generated symbols during development.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/QuickDoc · high confidence
F\# Code Structure and Run Markers support
The F\# plugin now provides a dedicated Code Structure view for F\# files, displaying modules, types, members, and pattern bindings, and enables 'Go to Class Member' navigation for F\# modules. Additionally, run markers are now supported for F\# files, allowing users to identify and run entry points and static methods directly from the editor gutter.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeStructure · high confidence
F\# Inlay Type Hints gain context menu actions
The F\# plugin now provides interactive context menu (bulb) actions for inlay type hints. Users can copy the inferred type to the clipboard via a new 'Copy Inferred Type' action, and can toggle the visibility of specific hint categories (top-level members, local bindings, and other patterns) directly from the hint's menu. This functionality is implemented through new highlighting and action provider components in the F\# PSI Daemon.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/Highlightings · high confidence
F\# code completion now supports NuGet package references in hash directives
The F\# plugin now provides code completion for NuGet packages when typing inside \#r (reference) or \#load (load) hash directives. A new completion provider detects string arguments in these directives and offers file completions for local assemblies as well as a 'nuget:' prefix to trigger package suggestions. This change also introduces new infrastructure classes to handle F\# compiler symbol lookups and presentation, ensuring that completion items display correct types and descriptions.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion · high confidence
F\# code generation for overrides and missing members now supports object expressions
The F\# plugin now allows users to generate method overrides and implement missing interface members within object expressions (objExpr), in addition to standard type declarations. This change introduces new generator context and provider components that detect when the cursor is inside an object expression and correctly generate the necessary member signatures, including handling base calls for non-abstract members and importing explicit parameter types. Users can now use the standard 'Generate' or 'Quick Fix' intentions to complete object expression implementations without manual boilerplate.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Generate · high confidence
F\# daemon stages restructured with new type hints and error processing
The F\# daemon analysis pipeline has been reorganized into a modular stage-based architecture, introducing several new capabilities for users. Type inference is now more visible through new Inlay Hints: the PatternTypeHintsStage displays inferred types for pattern matches, the PipeChainTypeHintStage shows return types for pipeline operators (with an option to hide same-line hints), and the InferredTypeCodeVisionProvider offers a Code Vision overlay for top-level bindings and members that can be copied to the clipboard. Error reporting and code inspection have also been enhanced: the FSharpErrorsStage now leverages the FCS for richer, more accurate error highlighting, while the FSharpCompilerWarningProcessor ensures compiler warnings are correctly treated as errors based on project configuration. Additionally, the plugin now provides VCS Code Vision ranges for better source control integration and highlights inherited members in the gutter for classes and interfaces.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/Stages · high confidence
F\# debugger support for async/task stepping and return value handling
The F\# debugger plugin now includes components to handle F\# async workflows and tasks, allowing the debugger to correctly step over and into these constructs. It also improves the display of return values, specifically filtering out F\# Unit types and handling return values from chains containing await calls. Additionally, the debugger now hides F\# compiler-generated frames (such as those from FSharpTypeFunc.Specialize) and intrinsic methods to provide a cleaner debugging experience.
ReSharper.FSharp/src/FSharp.Debugger/src · high confidence
F\# debugger support for smart step-into and local variable inspection
The F\# plugin now provides core debugger integration for F\# code, enabling features such as Smart Step Into, local variable inspection, and expression evaluation. This is implemented via new components including \FSharpBreakpointVariantsProvider\ for handling breakpoint locations (including multi-method breakpoints for async computations), \FSharpDebuggerLocalSymbolProvider\ for resolving local values, \FSharpExpressionEvaluationInfoProvider\ for parsing and evaluating expressions, and \FSharpSourceCallableExpressionsProvider\ for identifying callable expressions while respecting inline attributes. The debugger zone is also registered to enable these capabilities within the IDE.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Debugger · high confidence
F\# plugin frontend implementation and F\# Interactive enhancements
The F\# plugin now includes a comprehensive Java-based frontend implementation for Rider, introducing features such as NuGet package completion within reference directives, improved backspace handling for F\# string literals and brackets, and support for typing assists. F\# Interactive (FSI) capabilities are expanded with command history, syntax highlighting for input and output, gutter icons for commands and results, and the ability to send code to FSI with debug support. Additionally, the project view now supports moving F\# files and folders while respecting compile order, and inline breakpoints are disabled in F\# files to avoid usability issues.
rider-fsharp/src/main/java/com/jetbrains/rider/plugins/fsharp · high confidence
F\# typing assist and structural support
The F\# plugin now includes a dedicated typing assist implementation (FSharpTypingAssist.fs) that handles indentation, bracket pairing, and line continuation for F\# syntax, including specific support for single-line if expressions and multiline strings. This change also introduces utility components like ReadLockCookieUtil and ZoneMarker files to integrate these features into the plugin's architecture.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src · high confidence
Initial F\# backend support for JetBrains Rider
This change introduces the initial F\# language support plugin for JetBrains Rider, adding a .NET-based backend (ReSharper.Host plugin) and an IntelliJ Platform frontend. The plugin leverages FSharp.Compiler.Service and Fantomas to provide features such as code completion, quick fixes, debugger stepping, and type inference. The repository now includes the necessary build infrastructure (Gradle, .NET SDK requirements) and documentation to build and install the plugin, alongside configuration files for code style and version control.
(repo-wide) · high confidence
Initial F\# language support in Rider
This change introduces the foundational support for the F\# language in Rider, including file type definitions for standard (.fs), signature (.fsi), and script (.fsx) files, along with a dedicated lexer, syntax highlighter, and a dummy parser for basic structure. It also adds SQL language injection support within F\# string literals, enabling IDE features like code completion and navigation for SQL code embedded in F\# strings, and provides initial project templates for F\# class libraries and console applications.
rider-fsharp · high confidence
Introduce F\# Language Service for Rider lightweight backend
Adds a new \LanguageService\ implementation for F\# in the \ReSharper.FSharp\ plugin, enabling support for the Rider lightweight backend. This change introduces core components including \FSharpLanguageService\, \FSharpDeclaredElementPresenter\, \FSharpDeclaredElementIconProvider\, and \FSharpImportTypeHelper\, which provide essential IDE features such as element presentation, icon display, and import type resolution. It also includes \FSharpBreadcrumbsHelper\ for breadcrumb navigation, \FSharpQuickDefinitionService\ for quick definitions, and \FSharpLanguageSpecificCopyPasteBehavior\ to disable smart copy-paste. The implementation is marked with appropriate zone markers (e.g., \IRiderFeatureZone\, \IReSharperHostNetFeatureZone\) to integrate with Rider's backend architecture.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/LanguageService · high confidence
Introduce F\# matching brace highlighting and type provider protocol infrastructure
The F\# plugin now highlights matching braces (parentheses, brackets, and quotes) in the editor, providing visual feedback for unmatched delimiters. Additionally, the type provider support has been expanded with new protocol utilities for boxing and unboxing static arguments and custom attributes, along with improved error handling for type provider instantiation failures.
(repo-wide) · high confidence
Introduce F\# type hints and refactor FCS checker infrastructure
Users can now see type hints for top-level bindings, local bindings, pipe return types, and other patterns in the editor, with settings to control their display. This release also refactors the underlying FCS checker infrastructure, introducing new services like FcsCheckerService and FcsProjectProvider to manage project model and file checking more efficiently, alongside improvements to script handling and assembly timestamp caching.
ReSharper.FSharp/src/FSharp/FSharp.Common · high confidence
Introduce native F\# code formatting engine
This change adds the core components for a new, native F\# code formatter within the plugin, replacing or supplementing previous formatting mechanisms. It introduces \FSharpCodeFormatter\ to handle token-level spacing and line-break decisions, \FSharpFormatterInfoProvider\ to define declarative rules for wrapping, indentation, and alignment, and \FSharpFormatSettingsKey\ to expose granular configuration options (such as brace styles, blank lines, and width limits) to users. This enables consistent, customizable code formatting for F\# files directly through the IDE's formatting settings.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/CodeFormatter · high confidence
Introduce protocol model layer for out-of-process F\# type providers
The F\# Type Providers plugin now includes a new set of model classes in the \ReSharper.FSharp.TypeProviders.Protocol.Models\ namespace to support running type providers in a separate process. This change adds proxy implementations for core reflection types—including \ProxyProvidedAssembly\, \ProxyProvidedMethodInfo\, \ProxyProvidedConstructorInfo\, \ProxyProvidedEventInfo\, \ProxyProvidedFieldInfo\, and \ProxyProvidedPropertyInfo\—along with their context-aware counterparts (e.g., \ProxyProvidedMethodInfoWithContext\). These classes act as intermediaries that fetch metadata and invoke methods via the \TypeProvidersConnection\ RPC channel, enabling the IDE to interact with generative type providers without blocking the main thread or requiring them to run in-process.
ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Models · high confidence
New F\# Code Style and Fantomas configuration pages
Users can now configure F\# formatting preferences directly within the IDE. A new 'Formatting Style' page exposes granular code style options (such as indentation, spacing, and line limits) for F\# files. Additionally, a dedicated 'Fantomas' page allows users to manage the Fantomas formatter, including selecting between bundled, global, or local dotnet-tool versions, with built-in validation and notifications for version compatibility or detection issues.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeStyle · high confidence
New F\# Interactive (FSI) settings page and tool detection
The F\# plugin now includes a dedicated settings page for F\# Interactive, allowing users to configure launch options such as auto-detection of the FSI tool, 64-bit (AnyCPU) execution, assembly shadow copying, custom executable paths, and specific language version targeting. The underlying implementation introduces a new \FsiDetector\ component that automatically discovers FSI tools from Visual Studio installations, legacy SDKs, Mono runtimes, and NuGet packages, alongside a new \FsiHost\ that manages the interactive session and a sandboxing utility that wraps commands to prevent module name collisions.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Fsi · high confidence
New F\# PSI utility classes for argument, expression, name, parameter, pattern, and symbol mapping
The F\# plugin introduces a suite of new utility classes in the PSI layer to improve code analysis and editing support. FSharpArgumentsUtil adds support for detecting and handling named arguments. FSharpExpressionUtil provides helpers to identify simple value, literal, and lambda expressions, and to traverse outermost parent expressions. FSharpNamesUtil handles escaped identifiers (backticks) and retrieves possible source names for declared elements. FSharpParameterDeclarationUtil and FSharpPatternUtil enhance parameter and pattern resolution, including support for tuple patterns and lambda parameters. FcsSymbolMappingUtil and FcsTypeMappingUtil improve the mapping between F\# Compiler Service symbols/types and the plugin's internal PSI elements. Additionally, ProvidedDeclarationsExtensions and XmlDocTemplateUtil support XML documentation generation for provided types.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Util · high confidence
New F\# PSI utility modules for deconstruction, attributes, and completion context
The F\# PSI services layer introduces a suite of new utility modules in the Util directory to support advanced language features. Deconstruction.fs provides the logic for handling pattern deconstruction of union cases and tuples, including name generation and usage tracking. FSharpAttributesUtil adds helpers for managing attribute lists, such as adding, removing, and resolving attributes on type declarations and bindings. FSharpAutoOpenUtil implements the logic to resolve and cache modules specified by \[AutoOpen\] attributes. FSharpBindUtil handles the binding of FCS symbols to PSI references, ensuring proper qualification. FSharpChangeTypeHelper implements the IChangeTypeHelper interface to allow changing types of declarations and patterns. FSharpCodeCompletionContext and FSharpCompletionUtil provide the infrastructure for F\#-specific code completion, including reparse contexts, reference fixing, and relevance marking. FSharpExpectedTypesUtil extracts expected types for function arguments, supporting pipe operators. FSharpExpressionUtil offers helpers for analyzing expression structures, such as identifying predefined function applications and computation expressions. FSharpExtensionMemberUtil distinguishes between source and compiled extension members for resolution. FSharpImportStaticMemberUtil supports the import and completion of static members.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Util · high confidence
New F\# XML documentation comment language support
The F\# plugin now includes dedicated support for parsing and navigating F\# XML documentation comments. This change introduces a new \FSharpXmlDocLanguage\ definition, a navigator to locate doc comment blocks from comment nodes, and a PSI implementation (\FSharpDocCommentXmlPsi\) that handles the structure and line endings of F\# doc comments, enabling better IDE features for documentation.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DocComments · high confidence
New F\# code cleanup modules for reformatting and removing redundancies
The F\# plugin now includes dedicated code cleanup modules for reformatting code and removing code redundancies. The reformatting module allows users to format F\# code using either the built-in ReSharper formatter or Fantomas, with support for formatting entire files or specific selections. The redundancy removal module enables automatic cleanup of unused opens and other code redundancies. These modules are integrated into the code cleanup service and can be configured through the code cleanup profile settings.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCleanup · high confidence
New F\# code intentions for lambda conversion, pattern deconstruction, and control flow
This update introduces a suite of new quick-fix intentions for F\# code. Users can now convert shorthand dot-lambda expressions and partially applied functions into standard lambda expressions, deconstruct patterns into multiple positional components, and transform between \if\/\elif\ structures or invert \if\ conditions. Additional intentions allow converting \let\ bindings to \use\ bindings, matching lambda expressions to parameters, and renaming files to match their single type or module name. The implementation also includes a new data provider infrastructure to support these context actions.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/Intentions · high confidence
New F\# daemon analyzers for code simplification and redundancy
The F\# daemon now includes a suite of new analyzers that detect redundant or simplifiable code patterns. Users will see warnings for redundant applications of functions like \id\, \ignore\, and \sprintf\ (when the format string is static), redundant \as\ patterns, and unnecessary \Attribute\ suffixes or parentheses in attribute declarations. The analyzers also suggest replacing \if-then-else\ expressions that simply return boolean literals with direct conditions, and flag redundant indexer dots in F\# 6.0+. Additionally, new checks identify redundant parentheses in expressions, patterns, and type usages, redundant backticks in identifiers, and unnecessary \new\ keywords when instantiating types. The \LambdaAnalyzer\ has been expanded to suggest replacing lambdas with built-in functions or simpler expressions, while the \RecordExprAnalyzer\ detects opportunities to simplify nested record updates (F\# 8.0+). Finally, gutter icons now indicate recursive invocations, distinguishing between tail-recursive, non-tail-recursive, and partial recursive calls.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/Analyzers · high confidence
New F\# daemon error and warning highlighting definitions
The F\# daemon now includes a comprehensive set of new error and warning highlightings for F\# code, defined in \ErrorHighlightings.fs\, \Errors.xml\, \FcsErrors.xml\, and supporting utility modules. This adds specific diagnostics for code redundancies (such as redundant parentheses, open directives, backticks, and attributes), lambda simplification suggestions, and various compiler errors like type equations, missing mutability, and undefined names, each with associated quick fixes and configurable severities.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Daemon · high confidence
New F\# lexer and preprocessor infrastructure
The F\# plugin now includes a dedicated lexer and preprocessor layer in the Parsing module. This introduces support for F\# preprocessor directives (\#if, \#elif, \#else, \#endif) with boolean expression evaluation, allowing conditional compilation logic to be handled during parsing. It also adds token definitions for bang variants of keywords (e.g., let!, match!, while!) and specific preprocessor tokens (\#warnon, \#nowarn), enabling more accurate syntax highlighting and parsing for these language features.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Parsing · high confidence
New F\# postfix templates for common coding patterns
The F\# plugin now includes several new postfix templates to speed up common coding tasks. You can use 'for' to iterate over enumerable collections, 'let' to introduce a variable binding, 'match' to create a pattern match expression, 'not' to apply the logical not function, 'with' to copy and update record fields, and 'new' to construct new record instances or object expressions. These templates are available in the PostfixTemplates directory and integrate with the existing F\# code completion and refactoring infrastructure.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/PostfixTemplates · high confidence
New F\# protocol model definitions for interactive host, type providers, and Fantomas
The rider-fsharp/protocol module introduces three new Kotlin-based protocol model files (RdFSharpModel.kt, RdFSharpTypeProvidersModel.kt, RdFantomasModel.kt) that define the communication contracts for the F\# plugin. RdFSharpModel.kt defines the F\# Interactive (FSI) host interface, including session management, project references, and editor actions like moving the caret on send. RdFSharpTypeProvidersModel.kt establishes the out-of-process type provider model, detailing how provided types, methods, parameters, and custom attributes are exchanged, along with resolution environments and instantiation parameters. RdFantomasModel.kt specifies the formatting protocol, including document and selection formatting arguments, parsing options, and version retrieval. These models enable the plugin to communicate with the F\# compiler service (FCS) and external tools like Fantomas and type providers via the Rider protocol framework.
rider-fsharp/protocol · high confidence
New F\# quick fixes for common syntax and type errors
This update introduces a suite of new quick fixes for the F\# language, allowing you to automatically resolve common errors directly from the error list or light bulb menu. Key additions include fixes for incomplete match expressions (adding missing patterns or a catch-all clause), correcting type mismatches by changing parameter or variable types, and resolving syntax issues such as adding missing parentheses to function applications, adding setters to properties, or converting let bindings to use bindings. The diff also includes fixes for adding the Extension attribute to members, handling unused value warnings by adding an underscore prefix, and generating missing interface or record fields.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes · high confidence
New F\# refactorings: Inline Variable, Introduce Variable, and Rename support
The F\# plugin now provides dedicated implementations for the Inline Variable, Introduce Variable, and Rename refactorings. The Inline Variable refactoring (FSharpInlineVariable) handles F\#-specific patterns, such as inlining let bindings and managing parentheses, while respecting constraints like avoiding inlining of function parameters or values with write usages. The Introduce Variable refactoring (IntroduceVariable) allows extracting expressions into new local bindings, with logic to correctly place the new declaration within F\# syntax structures like sequential expressions and bindings. Additionally, the Rename refactoring (Rename) is enhanced to support F\#-specific elements, including anonymous record fields, union cases, and generated constructor parameters, ensuring that renaming propagates correctly to secondary elements like generated members.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Refactorings · high confidence
New F\# test host infrastructure for diagnostics and debugging
A new test host component has been introduced to expose internal F\# plugin state and runtime information for testing and debugging purposes. This host registers a suite of diagnostic endpoints, including dumping project mappings, local references, FCS project stamps, and module reader details. It also provides visibility into the Fantomas formatter (version, run options, termination) and the Type Providers runtime (version and process dump). Additionally, it supports dynamic culture switching and exposes Fantomas notifications, allowing tests to verify formatting behavior and notification handling in isolation.
ReSharper.FSharp/src/FSharp/FSharp.Tests.Host · high confidence
New context highlighters for F\# type parameters and usages
The F\# plugin now includes two new context highlighters to improve code visibility. FSharpTypeParametersMatchingBracesContextHighlighter highlights matching braces for type parameters, including angle brackets for postfix and prefix type argument lists, and parentheses for prefix type parameter declarations. FSharpUsagesContextHighlighter highlights all usages of the element under the cursor, including support for wild patterns and specific handling for active pattern cases and the greater-than operator to avoid false positives with generic type parameters.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/ContextHighlighters · high confidence
New options page for F\# type hints
Users can now configure F\# type hint visibility through a dedicated options page nested under the main Inlay Hints settings. This page exposes controls to show or hide type hints for top-level members, local bindings, other patterns, and specifically pipe return types, including an option to hide same-line pipe hints.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/Options · high confidence
Sticky lines support for F\# code structures
The F\# plugin now supports sticky lines, keeping key structural elements visible while scrolling. This includes nested modules, type declarations, members, auto-properties, type extensions, interface implementations, let bindings, object expressions, for/while loops, lambdas, match expressions, if/elif/else blocks, match clauses, and secondary constructors.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/StickyLines · high confidence
Support for F\# compiler-generated members in the PSI
The F\# plugin now exposes compiler-generated elements—such as record constructors, union case tags, and structural equality methods—to the ReSharper PSI. This enables IDE features like navigation, refactoring, and code analysis to correctly understand and interact with these implicit members, improving the accuracy of F\# code intelligence.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement/CompilerGenerated · high confidence
Support for F\# raw interpolated strings
The F\# lexer now recognizes and correctly tokenizes raw interpolated strings (e.g., $$$$"""...""""), a feature introduced in recent F\# versions. This change updates the lexer rules and state management to handle the specific delimiters and escaping behavior of raw strings, ensuring that code using this syntax is parsed without errors.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Parsing/Lexing · high confidence
Support for external annotations in F\# plugin
The F\# plugin now supports external annotations, allowing users to apply metadata (such as nullability or attribute-based hints) from external XML files to F\# code. This is implemented via a new \FSharpExternalAnnotationsFileProvider\ that loads annotation files from the plugin's \annotations\ directory, and a \FSharpAnnotatedMembersCacheProcessor\ that scans F\# source files to detect and apply these annotations to types, members, constructors, and parameters.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Annotations · high confidence
Support for rearranging F\# code elements
Users can now rearrange the order of specific F\# code elements using the IDE's Rearrange Code feature. This change introduces support for reordering tuple patterns, OR/AND patterns, tuple expressions, lambda parameter patterns, record field declarations, function parameters, enum case declarations, and match clauses within their respective containers.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/RearrangeCode · high confidence
Removals
Removal of legacy F\# PSI infrastructure files
The FSharp.psi grammar definition file, along with FSharpProjectFileLanguageService.cs and FSharpPsiProperties.cs, have been removed from the Psi.FSharp module. This cleanup eliminates legacy components related to the F\# project file language service and PSI properties, reflecting the ongoing migration of the F\# backend support to a new architecture.
ReSharper.FSharp/src/Psi.FSharp/src · high confidence
Removal of legacy F\# PSI tree implementation classes
The F\# PSI implementation in this location has removed the legacy \FSharpCompositeElement\ and \FSharpToken\ classes. These classes, which previously handled composite tree nodes and token parsing for the F\# language, are no longer present in the codebase, indicating a shift in how the F\# backend structures its parse tree.
ReSharper.FSharp/src/Psi.FSharp/src/Impl · high confidence
Removal of legacy F\# project properties infrastructure
The legacy F\# project properties implementation has been removed from the Projects.FSharp module. This change deletes the \FSharpProjectProperties\ class, its factory (\FSharpProjectPropertiesFactory\), the file properties provider (\FSharpProjectFilePropertiesProvider\), and the associated \AssemblyInfo.cs\. Consequently, the specific legacy mechanism for handling F\# project metadata and serialization via these classes is no longer present in this component.
ReSharper.FSharp/src/Projects.FSharp · high confidence
Architecture
ReSharper.FSharp project structure reorganized and build system modernized
The ReSharper.FSharp plugin has been restructured into a modern .NET SDK-style solution. The solution file now includes a comprehensive set of projects (FSharp.Psi, FSharp.Psi.Features, FSharp.Fantomas.Host, FSharp.TypeProviders.Host, FSharp.Debugger, etc.) organized under 'src' and 'test' folders, replacing the previous flat structure. Build configuration is centralized in new Directory.Build.props files, setting C\# language version to 12 and enforcing assembly signing. The .NET SDK version is pinned to 10.0.100 via global.json. Additionally, internal debugging actions for dumping FCS projects and PSI trees have been added, and out-of-scope completion is disabled by default in the solution settings.
ReSharper.FSharp · high confidence
Refactored F\# PSI declared element hierarchy
The F\# plugin's PSI layer has been restructured to introduce a new base class, FSharpDeclaredElementBase, and a suite of specialized declared element implementations (such as FSharpFunctionBase, FSharpMemberBase, FSharpPropertyBase, and FSharpFieldBase). This refactoring standardizes how F\# constructs like functions, properties, fields, and operators are represented in the PSI tree, ensuring consistent handling of attributes, access rights, and type information across the F\# language support.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement · high confidence
Behavioural changes
6 commits (1 fix) modifying ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Strategies
A change to existing behaviour in ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Strategies — 6 commits (1 fix), 1 file: “\[dotnet\] obsolete default ctor of SolutionComponentAttribute”; “Plugins: Split resharper-fsharp/ReSharper.FSharp/src subplatform to FSharp,FSharp.Fantomas.Host,FSharp.TypeProviders.Host”; “Completion/rules/suggestions: suggest names for isInstPat types in asPat”; and 3 more.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Strategies · medium confidence · unverified
7 commits (1 fix) modifying ReSharper.FSharp/src/FSharp.RiderPlugin
A change to existing behaviour in ReSharper.FSharp/src/FSharp.RiderPlugin — 7 commits (1 fix), 4 files: “\[dotnet\] Update .NET SDK in open source builds”; “misc rider: update JetBrains.NetFxBridge to 0.0.15”; “misc \[dotnet\]: JetBrains.NetFxBridge to 0.0.6”; and 4 more.
ReSharper.FSharp/src/FSharp.RiderPlugin · medium confidence · unverified
Added F\# code cleanup and reformatting resource strings
New localized resource strings have been added to support F\# code cleanup and reformatting features. Users will see specific UI labels for the 'Reformat F\#' action, the general 'Reformat code' cleanup task, and the 'Processing redundancies in F\# code' action, enabling proper internationalization of these existing code-cleanup capabilities.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/Resources · high confidence
Added localization strings for F\# type hints and inferred types
This change introduces the resource files (Strings.resx and generated Strings.Designer.fs) that provide the user-facing text for F\# inlay hints. It defines the labels and descriptions for the new 'Signatures' options page, including settings for showing return types in pipe chains (\|\>), hiding hints on same-line pipes, and configuring hints for top-level members and local bindings. It also includes strings for the 'F\# Inferred types' Code Vision provider, such as the tooltip for copying inferred types.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/Resources · high confidence
Build script updates for F\# Type Providers Host packaging and configuration
The F\# Type Providers Host build process now explicitly handles runtime configuration and application settings during packaging. It copies the \tploader.unix.runtimeconfig.json\ and \tploader.win.runtimeconfig.json\ files to the output directory to ensure the correct runtime environment is available, and it registers the \FSharp.TypeProviders.Host.exe.config\ file for installation alongside the host executable.
ReSharper.FSharp/src/FSharp.TypeProviders.Host/BuildScript · high confidence
Deadlock-safe type action provider interface
The FSharp plugin introduces a new interface, ISpecifyTypeActionProvider, which defines how type specification actions are created for F\# code elements. This interface is explicitly annotated with a 'DeadlockSafe' requirement, ensuring that the creation of these quick-fix actions does not introduce threading deadlocks during UI operations.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Intentions · high confidence
Disable context navigation for F\# functional members
Context navigation features (such as 'Find Usages' and 'Find Inheritors') are now disabled for F\# functional members. The new \FSharpBaseContextSearch\ and \FSharpInheritorsContextSearch\ classes explicitly return \false\ for \IsAvailable\, ensuring these navigation actions are not offered in the context menu for F\# code, while the utility class \FSharpContextNavigationUtil\ defines the specific element types (modules, record fields, union cases) that are subject to this restriction.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Navigation · high confidence
Enhanced F\# Find Usages with specific occurrence kinds and generated element support
The F\# Find Usages feature now distinguishes between different types of code references using specific occurrence kinds, such as recursive invocations (distinguishing tail vs. non-tail), partial applications, copy-and-update expressions, and pattern matches, each with corresponding icons in the navigation UI. Additionally, searching for generated elements (like those from union cases or indexed accessors) now correctly resolves to their origin elements, ensuring that find-usages results point to the actual source definitions rather than the generated artifacts.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Search · high confidence
Enhanced smart selection for F\# accessors, bindings, and interpolated strings
The F\# plugin now provides more precise 'Extend Selection' behavior for specific language constructs. When selecting code within \with\ accessor clauses, the selection now correctly spans from the \with\ keyword to the end of the member. Additionally, selecting a binding or an expression within a \let\/\use\ statement will now extend to include the entire binding declaration. The provider also handles interpolated strings more intelligently, allowing selection to expand to include surrounding literal parts or the full interpolated expression depending on the cursor position.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/ExtendSelection · high confidence
F\# PSI cache parts now store detailed member and extension metadata
The F\# PSI cache implementation in the \Parts\ directory has been updated to persist richer structural information for F\# types and modules. Cache parts for classes, interfaces, enums, delegates, exceptions, and modules now explicitly store lists of value, function, literal, and active pattern names, as well as specific extension member information. This allows the IDE to resolve and navigate F\# module members and extension methods more accurately without re-parsing source files.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2/Parts · high confidence
F\# PSI layer restructured with new interfaces and compile-order metadata support
The F\# PSI layer has been reorganized to introduce a comprehensive set of new interfaces (such as IFSharpDeclaredElement, IFSharpParameterOwner, and IFSharpTypeMember) and implementation classes for generated elements like active pattern cases and union case fields. This restructuring supports more precise semantic modeling of F\# constructs. Additionally, the plugin now exposes F\# CompileOrder metadata to the frontend via the FSharpViewPresenterExtension, enabling the IDE to respect build ordering defined in project files.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src · high confidence
F\# PSI services module zone registration and lock cookie aliasing
The F\# PSI services module now explicitly registers its plugin zone requirements via new ZoneMarker files, ensuring the service layer correctly declares its dependency on the IFSharpPluginZone. Additionally, a ReadLockCookie utility file has been added to alias the read lock cookie type to NonCSharpInteropReadLockCookie, standardizing lock handling within this specific F\# service context.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src · high confidence
F\# Type Providers now run in a separate out-of-process host
The F\# Type Providers protocol has been refactored to execute type provider loading in a dedicated external process rather than within the main IDE process. This change introduces a new host executable (JetBrains.ReSharper.Plugins.FSharp.TypeProviders.Host) and a protocol layer (TypeProvidersConnection, TypeProvidersExternalProcess) to manage the lifecycle and communication with this isolated process. To support this separation, a 'TcImportsHack' mechanism was added to serialize type provider import data across process boundaries, and the plugin's zone markers were updated to require the RD Framework and Rider Model zones. This isolation improves stability by preventing type provider crashes from affecting the main IDE and resolves issues with locating out-of-process assemblies in monorepo setups.
ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src · high confidence
F\# Type Providers now run in a separate process
The F\# Type Providers Host has been restructured to execute type provider logic in an out-of-process host, isolating it from the main IDE process. This change introduces a new architecture where the host manages caching for provided types, assemblies, and constructors, and exposes functionality via remote protocol models. For users, this improves stability by preventing type provider crashes from affecting the entire IDE and enhances performance through better resource isolation.
ReSharper.FSharp/src/FSharp.TypeProviders.Host/FSharp.TypeProviders.Host/src · high confidence
F\# code completion rules are rewritten to use a new declarative rule architecture
The F\# code completion engine in the ReSharper F\# plugin has been refactored from a monolithic provider into a modular system of specific rules (e.g., \FSharpKeywordsRule\, \FSharpRelevanceRule\, \GenerateLambdaRule\). This change introduces F\#-specific behaviors such as generating lambda expressions from expected types, auto-completing match expression patterns, and handling interface member implementation. It also improves the relevance and filtering of suggestions by emphasizing union cases, de-emphasizing operators, and correctly handling F\# keywords and computation expressions.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules · high confidence
F\# code folding parity with Classic Rider
The F\# plugin now provides code folding capabilities that match the behavior of the Classic Rider experience. A new folding processor has been added to handle outlining for imports, attributes, comments, XML documentation, and members, ensuring consistent user experience across different folding scenarios.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Foldings · high confidence
F\# daemon usage checking bypasses the UnknownLanguage stage
The F\# language plugin now explicitly disables the UnknownLanguage stage in its usage checking daemon. By setting UseUnknownLanguageStage to false and providing a dummy usage analyzer, the F\# code path no longer triggers the generic fallback logic intended for unrecognized languages, ensuring that usage analysis runs correctly within the F\#-specific pipeline.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/UsageChecking · high confidence
F\# identifier tooltips now use language-specific syntax highlighting
The F\# plugin now applies distinct syntax highlighting styles to the various elements (keywords, types, methods, variables, etc.) displayed in identifier tooltips. Previously, these tooltips likely used generic styling; this change ensures that the information presented in the status bar tooltip matches the visual style of the code editor, improving readability and consistency for F\# developers.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/Highlightings · high confidence
F\# plugin bundled with Rider via new build and install scripts
The F\# plugin is now bundled with Rider by introducing build scripts that define the F\# plugin, debugger, Fantomas, and Type Providers as subplatform components, and install steps that register these components as bundled artifacts and exempt them from zoning validation.
ReSharper.FSharp/src/FSharp.RiderPlugin/BuildScript, ReSharper.FSharp/src/FSharp.RiderPlugin/src · high confidence
F\# project model base refactored with improved cancellation and file system shims
The F\# plugin's project model base has been restructured to improve stability and responsiveness. New shims for the F\# Compiler Service (FCS) file system now properly delegate file operations and listen for solution changes, ensuring the IDE reacts correctly to file modifications. A dedicated request queue and utility methods manage read locks, allowing FCS background analysis to be cancelled cleanly without blocking the UI or causing reentrancy issues. Additionally, the plugin now supports F\# signature files (.fsi, .mli) as a distinct project file type, and default build actions are explicitly defined for F\# source and script files.
ReSharper.FSharp/src/FSharp/FSharp.ProjectModelBase · high confidence
Fantomas external process now supports .exe executables and uses internal runtime
The F\# Fantomas protocol layer has been refactored to launch the Fantomas host process using an internal runtime and to support .exe executables in addition to .dll files. This ensures that formatting works correctly even when the bundled Fantomas host is produced as an executable, and aligns the process startup logic with the monorepo's assembly layout.
ReSharper.FSharp/src/FSharp/FSharp.Fantomas.Protocol · high confidence
Fantomas host plugin upgraded to .NET 8 and Fantomas 7.0.3
The Fantomas host subplatform now targets .NET 8 (net8) and bundles Fantomas version 7.0.3, replacing the previous .NET Core 6 runtime. This upgrade enables server garbage collection and includes updated dependencies such as FSharp.Core 10.0.103 and JetBrains Rider framework 2026.3.2, ensuring compatibility with the latest Rider backend and improved performance characteristics for code formatting operations.
ReSharper.FSharp/src/FSharp.Fantomas.Host · high confidence
Fantomas integration runs in a separate out-of-process host
The F\# Fantomas code formatter now executes in a dedicated external process rather than within the main IDE process. This host process communicates with the plugin via an RD protocol endpoint, handling assembly resolution and loading of the specific Fantomas version (including support for Fantomas 5.0+ API changes) to improve stability and isolate formatting operations.
ReSharper.FSharp/src/FSharp.Fantomas.Host/src · high confidence
Fix zone issues in FSharp plugin
Added zone marker files to the F\# PSI Daemon to resolve zone-related issues, ensuring the plugin correctly registers its requirements within the ReSharper application zones.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon · high confidence
Improved F\# language injection support for strings and regex
The F\# plugin now provides more robust language injection for string literals, including support for named arguments, compiled properties, and raw strings. It also adds an 'fsharp' to 'F\#' alias for string syntax annotations and disables regex injections for interpolated strings with holes to prevent parsing errors. Additionally, the injection targets finder now supports common injection function names (html, css, sql, js, json, etc.) and specific type providers (SqlCommandProvider, JsonProvider, XmlProvider).
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Injected · high confidence
Improved F\# metadata reading and auto-open module caching
The F\# plugin now uses a dedicated metadata reader to parse F\# signature data from assembly resources, which resolves issues with duplicate literal items and improves the handling of auto-open modules in compiled code. A new caching mechanism for auto-open modules ensures that type imports are correctly resolved for compiled modules, fixing previous inconsistencies in how nested modules and namespaces were imported.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Metadata · high confidence
Improved F\# source code accessibility and argument resolution
The F\# plugin now correctly handles source-level accessibility rules, including file-private types and signature-file visibility, ensuring that code analysis respects F\# scoping constraints. Additionally, argument resolution for named parameters and union cases has been refined to better handle tuples and property initializers, improving the accuracy of navigation and quick-fixes.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl · high confidence
Improved F\# tooltip support and annotation packaging
The F\# plugin now ensures that XML documentation for the F\# Core DLL is included in the distribution package, which restores proper tooltip functionality in certain scenarios. Additionally, the build process has been updated to explicitly copy F\# annotations from the Rider extension directory into the plugin package, ensuring these resources are available at runtime.
ReSharper.FSharp/src/FSharp/BuildScript · high confidence
Improved cache invalidation for F\# type provider abbreviations
The F\# plugin now more accurately tracks changes to type abbreviations defined by type providers. A new \ProvidedAbbreviationTypePartInvalidator\ component listens for symbol cache updates and marks affected type abbreviations as dirty, ensuring that the IDE's code analysis and navigation features reflect the latest state of type provider definitions without requiring a full restart or manual cache clearing.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/TypeProviders · high confidence
Improved detection of multiline TODO comments in F\#
The F\# TODO language service now correctly identifies TODO items within multiline block comments (delimited by (\* \*)). Previously, these comments might have been ignored or handled incorrectly; the new implementation explicitly checks for the BLOCK\_COMMENT token type and extracts the content between the delimiters, ensuring that TODO markers inside such comments are now recognized and displayed in the TODO list.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/TodoItems · high confidence
Include Fantomas runtime config and deps files in plugin package
The F\# Fantomas Host plugin now explicitly packages its runtime configuration files (Fantomas.Host.unix.runtimeconfig.json and Fantomas.Host.win.runtimeconfig.json) and the dependency manifest (JetBrains.ReSharper.Plugins.FSharp.Fantomas.Host.deps.json) into the plugin distribution. This ensures the Fantomas host process has the necessary configuration and dependency resolution files available at runtime within the ReSharper product home directory.
ReSharper.FSharp/src/FSharp.Fantomas.Host/BuildScript · high confidence
Introduce F\# compiled type element cache for improved PSI accuracy
The F\# plugin now uses a new cache layer in the PSI implementation to represent compiled F\# types (classes, structs, enums, interfaces, delegates, and modules) and their members. This change ensures that source-level accessibility rules, such as \RequireQualifiedAccess\ and \AutoOpen\, are correctly applied to compiled types, and enables proper import and completion support for F\#-specific constructs like active patterns, module literals, and static extension members.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2/Compiled · high confidence
Introduce structured caching for F\# type provider entities
The F\# Type Providers protocol layer now uses a dedicated cache infrastructure to store and manage provided types, assemblies, and abbreviations. This change adds a generic caching base class and specific implementations for provided types, assemblies, generic types, and static argument applications, enabling efficient retrieval and batch operations. It also introduces a module-level cache for provided abbreviations to support in-memory analysis of generative type providers, improving performance and reducing redundant protocol calls when resolving type information.
ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Cache · high confidence
Migrate F\# projects to new project format
The \AssemblyInfo.cs\ files in the \Psi.FSharp\ and \Psi.FSharp.LanguageService\ projects have been removed. This change reflects the migration to the new SDK-style project format, where assembly metadata is now managed directly within the project files rather than through separate code-behind files.
ReSharper.FSharp/src/Psi.FSharp.LanguageService/Properties, ReSharper.FSharp/src/Psi.FSharp/Properties · high confidence
New F\# PSI Cache2 implementation
The F\# plugin now uses a new Cache2-based PSI implementation to improve performance and reliability. This change introduces a new cache provider and declaration processor that serialize F\# language constructs (such as modules, types, and object expressions) into persistent parts, replacing the previous caching mechanism.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2 · high confidence
New F\#-specific reference search implementation
The F\# plugin now uses a dedicated search infrastructure (FSharpReferenceSearcher, FSharpSearchFilter, and FSharpSearcherFactory) to improve the accuracy and performance of Find Usages and Go to Declaration. This new logic respects F\# source accessibility rules—excluding private members from cross-file searches—and handles F\#-specific constructs such as union cases, active patterns, indexed properties, and generated parameters, ensuring references are found and navigated correctly within the F\# PSI.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Searching · high confidence
Refactored F\# daemon stages to improve performance and filtering
The F\# daemon analysis infrastructure has been refactored to introduce base classes (FSharpDaemonStageBase, FSharpDaemonStageProcessBase) that implement the IModernDaemonStage interface. This change enables more efficient filtering by allowing stages to specify whether they should run only on visible documents or signature files, addressing performance issues in filtered analysis modes. The HighlightIdentifiersStage now leverages this new structure to optimize how identifier highlightings are generated and applied.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/Stages · high confidence
Refactored F\# symbol resolution and caching infrastructure
The F\# plugin's symbol resolution and caching logic in the Resolve directory has been restructured to improve reliability and performance. A new FcsCapturedInfoCache now manages FCS data with proper invalidation for scripts and projects, supporting read-only forks for lightweight backends. The core FSharpSymbolReference class has been updated to handle generic type substitutions and improved access context checks, while specialized references (CtorReference, TypeReference, TypeExtensionReference) ensure accurate symbol resolution for constructors, types, and extensions. Utility classes like FSharpParameterUtil provide robust parameter name extraction for complex patterns.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Resolve · high confidence
Reimplemented F\# PSI tree node implementations
The F\# PSI tree implementation in the \Impl/Tree\ directory has been rewritten to provide more robust support for F\# language constructs. This includes proper handling of abstract member declarations, auto-properties, and access modifiers, as well as improved parsing and resolution for active patterns, object expressions, and dot-lambdas. The changes also introduce better support for record type spreads, computed do-expressions, and chameleon expressions, ensuring that the IDE's understanding of F\# code structure aligns more closely with the F\# Compiler Service (FCS) model.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Tree · high confidence
Removal of F\# fake parser and language service stubs
The F\# language service no longer uses the temporary fake parsing infrastructure. The \FSharpFakeParser\, \FSharpFakeTreeBuilder\, \FSharpLanguageService\, and \FSharpPsiBuilderTokenFactory\ classes have been removed from the codebase, indicating that the initial stub implementation for F\# parsing and language support has been cleaned up or replaced.
ReSharper.FSharp/src/Psi.FSharp.LanguageService/src · high confidence
Removal of generated F\# parser and PSI stubs
The auto-generated F\# parser and PSI (Program Structure Interface) stubs in the Gen directory have been removed. This includes the generated parser base class, token bitsets, element types, file navigator, and visitor interfaces. These files were previously created by IntelliJ's parserGen tool and are no longer present in the codebase, indicating a shift away from this specific code-generation approach for the F\# backend.
ReSharper.FSharp/src/Psi.FSharp/src/Gen · high confidence
Removal of legacy F\# lexer and token infrastructure
The F\# parsing layer in the Psi.FSharp module has removed the legacy lexer implementation and its associated token definitions. Specifically, the \FSharpFakeLexer\, \FSharpLexer\, \FSharpTokenInfoEx\, \FSharpTokenNodeType\, \FSharpTokenType\ (including generated types and custom node types like WHITESPACE and NEW\_LINE), and the \FSharpTokens.xml\ configuration file have been deleted. This cleanup removes the manual token mapping and lexer logic that previously wrapped the F\# compiler services, indicating a shift in how the F\# backend handles lexical analysis.
ReSharper.FSharp/src/Psi.FSharp/src/Parsing · high confidence
Replaced F\# PSI parsing infrastructure with FCS-backed tree builders
The F\# plugin's parsing layer has been rewritten to use the F\# Compiler Service (FCS) directly. The previous hand-written parser has been replaced by new \FSharpParser\, \FSharpImplTreeBuilder\, \FSharpSigTreeBuilder\, and \FSharpTreeBuilderBase\ classes. This change shifts the responsibility of syntax tree construction to FCS, enabling support for modern F\# features (such as object expressions, spreads, and intersection types) and improving the accuracy of the PSI structure for both implementation (.fs) and signature (.fsi) files.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Parsing · high confidence
Reworked F\# PSI tree interfaces and navigators
The F\# PSI tree layer has been significantly refactored to improve code structure and navigation capabilities. New interfaces have been introduced for core language constructs, including \IAccessorDeclaration\ and \IAccessorOwnerDeclaration\ to better model property accessors, and \IFSharpDeclaration\ now distinguishes between source and compiled names. A comprehensive set of navigator classes (e.g., \AppExprNavigator\, \DotLambdaExprNavigator\, \FSharpSandBoxUtil\) has been added to simplify traversal of the syntax tree, particularly for application expressions and sandboxed contexts. Additionally, support for active patterns has been enhanced with dedicated interfaces like \IActivePatternId\ and utilities to retrieve case indices.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Tree · high confidence
Structured sorting for F\# parameter info candidates
The F\# parameter info feature now applies structured sorting to its candidate list, aligning its behavior with C\# and VB. This change ensures that parameter suggestions are ordered consistently and predictably, improving the developer experience when navigating function signatures in F\# code.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/ParameterInfo · high confidence
Support for record struct semantic highlighting
The F\# daemon now distinguishes record structs from regular records when generating semantic highlighting attributes. This change ensures that record structs are assigned a specific highlighting ID, allowing the IDE to apply distinct visual styling or behavior to them compared to standard reference-type records.
ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon · high confidence
Updated F\# code analysis and quick-fix messages
The F\# plugin's resource strings have been regenerated to include new messages for code cleanup and analysis features. Users will now see updated suggestions for simplifying lambda expressions, handling nested record updates, and managing mutable struct values, alongside existing messages for redundant patterns and syntax.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/Resources · high confidence
Updated F\# intention strings for warning suppression and import actions
The resource strings for F\# quick-fix intentions have been updated to support new warning suppression directives and import actions. Users will now see options to disable inspections using '\#nowarn' and '\#warnon' directives (e.g., 'Disable in file with '\#nowarn''), in addition to existing comment-based disable options. The 'Import module' action text has also been updated to support multiple choices for extension members.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/Resources · high confidence
Updated FSharp.Core binding redirect in Type Providers Host
The FSharp.TypeProviders.Host application now redirects all versions of FSharp.Core (2.0.0.0 through 99.9.9.9) to version 10.0.0.0. This change replaces previous binding redirects for Mono.Cecil and System.Collections.Immutable, ensuring the host process uses the updated FSharp.Core library required by the recent FCS update.
ReSharper.FSharp/src/FSharp.TypeProviders.Host/FSharp.TypeProviders.Host · high confidence
Fixes
Resolves F\# plugin zone registration issues
The F\# plugin now correctly registers its plugin zone via a new ZoneMarker class, ensuring proper initialization and scope within the ReSharper environment. Additionally, a utility type alias for ReadLockCookie has been introduced to standardize lock handling in the F\# PSI intentions layer.
ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src · high confidence
Test coverage
3 commits adding/updating tests in ReSharper.FSharp/test/data/features/daemon/strings; Add test package lock and subplatform configuration; Added C\# interop resolve test baselines for F\# types; Added F\# code completion test baselines for filtered expressions; Added F\# daemon error highlighting test baselines; Added F\# keyword completion tests for various code contexts; Added F\# quick-fix import tests for module members; Added F\# symbol cache test baselines for accessibility, modules, and types; Added F\# symbol resolution test data for active patterns, qualified names, and indexers; Added F\# test assembly sources for extension and member resolution; Added F\# test infrastructure and stubs; Added F\# test suite for code completion, navigation, and parameter info; Added JUnit tests for F\# lexer and parser; Added completion tests for F\# custom operations; Added lexer and parser tests for F\# language features; Added lexer test baselines for F\# syntax elements; Added name resolution test data for F\# checker; Added naming suggestion tests for F\# expression contexts; Added navigation test baselines for F\# enums, exceptions, interfaces, virtual members, and object expressions; Added navigation tests for F\# anonymous records, dot lambdas, and wildcards; Added parser tests for F\# string literals and concatenation; Added parsing error test cases for F\# expressions; Added parsing tests for F\# attributes, directives, and active patterns; Added quickdoc test cases for F\# language constructs; Added service-layer tests for F\# plugin; Added structure view tests for F\# file elements; Added syntax highlighting tests for F\# preprocessor branches and XML documentation; Added test baselines for F\# inferred type code vision; Added test baselines for F\# inheritance gutter marks; Added test baselines for F\# inheritors navigation; Added test baselines for F\# inline and introduce var refactorings; Added test baselines for F\# record field type signature quick fix; Added test baselines for override generation anchor points; Added test baselines for the AddUnderscorePrefix quick fix; Added test baselines for the F\# 'add missing seq' quick fix; Added test case for F\# upcast quick fix; Added test cases for F\# extension attribute quick fixes; Added test cases for F\# lambda simplification quick fixes; Added test cases for F\# parameter info auto-popup behavior; Added test cases for F\# partial-to-lambda intention; Added test cases for F\# quick fix to convert instance members to static; Added test cases for F\# quick fix to remove subsequent expressions; Added test cases for the AddParens quick fix; Added test cases for the F\# NamespaceToModule quick fix; Added test cases for the Remove Redundant 'new' quick fix in F\#; Added test coverage for F\# TODO and NotImplementedException detection; Added test data for F\# Generate Missing Members quick fix; Added test data for F\# ReplaceWithTypeRefExprFix quick fix; Added test data for F\# Simplify Lambda quick fix; Added test data for F\# Specify Type quick fix scenarios; Added test data for F\# ToMutable quick fix scenarios; Added test data for F\# XML documentation tooltips in C\# resolve scenarios; Added test data for F\# assembly auto-opens; Added test data for F\# attribute caching on declarations; Added test data for F\# comment line action behavior; Added test data for F\# daemon error highlighting and analyzer inspections; Added test data for F\# daemon recursion analysis; Added test data for F\# deconstruct intention; Added test data for F\# dot-lambda quick fix availability and behavior; Added test data for F\# extension method import quick fixes; Added test data for F\# interface member generation; Added test data for F\# match lambda to parameter intention; Added test data for F\# parameter info in curried contexts; Added test data for F\# redundant parentheses removal quick fix; Added test data for F\# redundant qualifier analysis; Added test data for F\# redundant qualifier quick fix; Added test data for F\# regex daemon detection; Added test data for F\# signature parameter renaming quick fix; Added test data for F\# simplified match clause quick fixes; Added test data for F\# type hints in patterns and settings; Added test data for F\# warning disable intentions; Added test data for Fantomas settings integration; Added test data for FcsCapturedInfoCache fork support; Added test data for RenameFileToMatchTypeName intention availability; Added test data for metadata reader type parsing; Added test data for redundant parentheses in F\# type usage contexts; Added test data for the 'Remove unexpected arguments' quick fix; Added test data for the ConvertTupleToArrayOrListElements quick fix; Added test data for the F\# Remove Inline quick fix; Added test data for the Remove Unnecessary Upcast quick fix; Added test data for the Use Named Access intention; Added test fixtures for F\# script file handling in project models; Added test infrastructure for F\# intentions; Added test infrastructure for subplatform lock file resolution; Added tests for F\# 'Replace with assignment expression' quick fix; Added tests for F\# AI summarizer context collection; Added tests for F\# C\# resolve and symbol caching; Added tests for F\# Invert If intention; Added tests for F\# QuickDoc generation; Added tests for F\# ReplaceIfWithCondition quick fix; Added tests for F\# Specify Types intention; Added tests for F\# ToLiteral intention; Added tests for F\# UseWildSelfId quick fix scenarios; Added tests for F\# XML documentation quick fixes; Added tests for F\# app expression daemon analysis; Added tests for F\# argument highlighting service; Added tests for F\# change type quick fix across arguments, records, and return types; Added tests for F\# code editing actions; Added tests for F\# code rearranging of enum, union, record, and match elements; Added tests for F\# completion import behavior within the same namespace; Added tests for F\# condition negation intention; Added tests for F\# debugger expression evaluation; Added tests for F\# extension method import quick-fix availability; Added tests for F\# format specifier highlighting; Added tests for F\# if/elif conversion intentions; Added tests for F\# import type quick fix accessibility and qualification rules; Added tests for F\# import type quick-fix availability; Added tests for F\# interpolated string candidate analysis; Added tests for F\# interpolated string quick fix; Added tests for F\# items container file and folder operations; Added tests for F\# lambda replacement quick fixes; Added tests for F\# list cons pattern simplification quick fix; Added tests for F\# override generation; Added tests for F\# pipe-chain type hints; Added tests for F\# postfix completion templates; Added tests for F\# predefined operator quick-fixes; Added tests for F\# project model and script modules; Added tests for F\# quick fixes; Added tests for F\# record field generation quick fix; Added tests for F\# record field signature quick fix; Added tests for F\# refactorings; Added tests for F\# replace return type quick fix; Added tests for F\# specify base type quick fix; Added tests for F\# type hint context actions; Added tests for F\# union case icon rendering; Added tests for RemoveConstructorFix on F\# types; Added tests for RemoveUnusedOpensFix; Added tests for ToModuleNamespaceDeclarationAction; Added tests for ToMultilineRecord intention with spread support; Added tests for ToMutable/ToImmutable record field intentions; Added tests for color highlighting of F\# integer literals and color properties; Added tests for completion import behavior in same namespace; Added tests for debugger expression evaluation info provider; Added tests for deconstructing union case fields; Added tests for file system shim delegation; Added tests for import completion in same namespace scenarios; Added tests for import quick-fix popup actions; Added tests for mutability signature quick fixes; Added tests for nested record field update analyzer and quick fix; Added tests for primitive type boxing and unboxing in type provider communication; Added tests for redundant attribute parentheses analysis and quick fix; Added tests for redundant attribute suffix analysis and quick fix; Added tests for regex completion in various F\# string contexts; Added tests for removing redundant RequireQualifiedAccess attributes; Added tests for removing unused self-id variables in F\# constructors; Added tests for scoped never-matching rule removal in F\#; Added tests for the 'Add parens to typed expression' quick fix; Added tests for the 'Replace if with condition operand' analyzer; Added tests for the 'Replace with Regular String' quick fix; Added tests for the F\# 'toObjExpr' quick fix; Added tests for the F\# Add Setter quick fix; Added tests for the F\# indexer dot quick fix; Added tests for the F\# quick fix that adds missing member self-identifiers; Added tests for the F\# quick fix to replace interpolated strings with triple-quoted literals; Added tests for the F\# redundant 'as' pattern quick fix; Added tests for the LetToUse intention; Added tests for the Remove Redundant Backticks quick fix; Added tests for the Remove Yield quick fix; Added tests for the RemovePatternArgument quick fix in F\#; Added tests for the Replace Use with Let quick fix; Added tests for the To Recursive Let Bindings intention; Added tests for the ToRecursiveLetBindings quick fix; Added typing-completion tests for F\# patterns, records, and union cases; Added usage-navigation tests for F\# language constructs; Expanded Find Usages occurrence kinds for F\#; Expanded daemon test coverage for F\# highlighting and analysis; Expanded test coverage for F\# assembly reader metadata scenarios; Expanded test coverage for F\# lambda analyzer edge cases; Expanded test coverage for F\# quick fixes and code cleanup; Expanded test coverage for F\# redundant parentheses analysis; Expanded test coverage for redundant parentheses in F\# patterns; Expanded test coverage for the Add Ignore quick fix; Expanded test coverage for the Introduce Var quick fix; Migrate F\# tests to JUnit 5 and Patch Engine; Test coverage for F\# 'Replace with \_' quick fix; Test infrastructure updates for F\# plugin; Updated F\# code completion test data for lambda, pattern, and record scenarios; Updated F\# completion test baselines for attributes, imports, and binding; Updated F\# identifier highlighting test baselines; Updated F\# signature parsing test baselines.
Dependencies
Establishes isolated build and dependency configuration for the F\# Type Providers Host
The FSharp.TypeProviders.Host module now includes its own Directory.Build.props and PackagesLock.targets files, creating a self-contained build environment. This setup pins specific versions for key dependencies including FSharp.Core (10.0.103), JetBrains.Annotations (2026.2.0), JetBrains.FSharp.Compiler.Service (2026.3.2), and Newtonsoft.Json (13.0.3), ensuring consistent package resolution for this subplatform.
ReSharper.FSharp/src/FSharp.TypeProviders.Host · high confidence
F\# Debugger package versions are now explicitly locked
The F\# Debugger module now uses a dedicated package-locking mechanism to ensure consistent dependency versions. A new \PackagesLock.targets\ file explicitly pins versions for key libraries including JetBrains.ICorDebug (2.0.20260929.5), FSharp.Core (10.0.103), and JetBrains.Annotations (2026.2.0), while \Directory.Build.props\ configures the build system to enforce these locks. This change stabilizes the debugger's runtime environment by preventing unintended version drift in its core dependencies.
ReSharper.FSharp/src/FSharp.Debugger · high confidence
F\# plugin project structure reorganized into subplatforms
The F\# plugin's build structure has been reorganized into distinct subplatforms: FSharp.Debugger, FSharp.Fantomas.Host, FSharp.RiderPlugin, FSharp.TypeProviders.Host (split into .NET Framework and .NET Core targets), and core F\# modules (Common, Fantomas.Protocol, ProjectModelBase, Psi.Daemon, Psi.Features, Psi.Intentions, Psi.Services). This change introduces separate project files for each component, establishing clear boundaries for dependencies and build targets (primarily net472, with Fantomas.Host targeting net8.0 and TypeProviders.Host.NetCore targeting netcoreapp3.1).
(dependencies) · high confidence
Introduces centralized package locking for the F\# subplatform
The F\# plugin source now uses a dedicated build structure to manage dependencies. A new \PackagesLock.targets\ file centrally defines the versions for key packages including Fantomas.Core (7.0.3), FSharp.Core (10.0.103), and JetBrains.FSharp.Compiler.Service (2026.3.2), while \Directory.Build.props\ imports this configuration. This change ensures consistent dependency resolution across the FSharp subplatform.
ReSharper.FSharp/src/FSharp · high confidence
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
How this codebase got here
Score
- CAI 50 → 42 (-8.0)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.
Lenses
- Code Health 53 → 29 (-23.6)
- Architecture 100 → 100 (+0.1)
- Maturity 53 → 58 (+4.4)
- Readiness 48 → 48 (+0.0)
- Security 42 → 42 (+0.0)
- Performance 100 → 100 (+0.0)
Resolved (21)
- Change coupling clique: FSharpVcsCodeVisionRangesProviderStage.fs, FsiHost.fs, SandboxDocumentLanguageSupportFSharpScript.fs (ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src/Stages/FSharpVcsCodeVisionRangesProviderStage.fs)
- Change coupling: FSharpCodeStructure.fs ↔ FSharpQuickDefinitionService.fs (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeStructure/FSharpCodeStructure.fs)
- Change coupling: FSharpGeneratedMemberBase.cs ↔ FSharpTypeMember.cs (ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement/CompilerGenerated/FSharpGeneratedMemberBase.cs)
- Change coupling: FantomasProcess.cs ↔ TypeProvidersExternalProcess.cs (ReSharper.FSharp/src/FSharp/FSharp.Fantomas.Protocol/src/FantomasProcess.cs)
- Change coupling: FsiOptionsPage.fs ↔ FSharpQuickDefinitionService.fs (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Fsi/FsiOptionsPage.fs)
- Coverage not measured — no coverage collector is wired up
- Duplicated block (27 lines × 2) (rider-fsharp/projectTemplates/FSharpClassLibraryTemplate/AssemblyInfo.fs)
- Duplicated block (6 lines × 2) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules/UnionCasePatternRule.fs)
- Duplicated block (6 lines × 2) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Util/FSharpBindUtil.fs)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/SwaggerProviderCSharp/CSharpLibrary/CSharpLibrary.csproj)
- End-of-life runtime: .NET netcoreapp3.1 (ReSharper.FSharp/src/FSharp.TypeProviders.Host/FSharp.TypeProviders.Host.NetCore/FSharp.TypeProviders.Host.NetCore.csproj)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules/GenerateLambdaRule.fs)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules/NameSuggestionRule.fs)
- Members sharing a duplicated core (4 members, 50+ identical tokens) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes/ImportMemberFix.fs)
- No ADRs found
- Off-boarding risk: anonymized user #1
- Off-boarding risk: anonymized user #2
- Off-boarding risk: anonymized user #3
- Orphaned file (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Injected/FSharpLiteralInjectionTarget.fs)
- Tests outside the analyzed solution
- …and 1 more
New (29)
- Change coupling: FsiHost.fs ↔ SandboxDocumentLanguageSupportFSharpScript.fs (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Fsi/FsiHost.fs)
- Duplicated block (20–22 lines × 2) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Util/StringLiteralsUtil.fs)
- Duplicated block (5 lines × 2) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules/GenerateMatchExprPatternsRule.fs)
- Duplicated block (9 lines × 2) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules/GenerateMatchExprPatternsRule.fs)
- Edited copies of one member (3 members, 19+ corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes/RemoveRedundantAttributeParensFix.fs)
- Edited copies of one member (3 members, 8+ corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Common/src/Checker/ZoneMarker.fs)
- Edited copies of one member (4 members, 7+ corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Common/src/ProjectModel/Host/ZoneMarker.fs)
- Edited copies of one member (4 members, 8+ corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/PsiFeaturesNamespaceZoneMarker.fs)
- Edited copy of a member (15 corresponding lines) (rider-fsharp/src/main/java/com/jetbrains/rider/plugins/fsharp/projectView/FSharpMoveProviderExtension.kt)
- Edited copy of a member (17 corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes/RemoveConstructorFix.fs)
- Edited copy of a member (20 corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes/RemoveUnnecessaryUpcastFix.fs)
- Edited copy of a member (8 corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/AI/ZoneMarker.fs)
- Edited copy of a member (9 corresponding lines) (ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Comment/FSharpDocCommentElementsItemsProvider.fs)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/ConsoleAppTwoTargetFrameworks/CoreConsoleApp.fsproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/CoreConsoleApp/CoreConsoleApp.fsproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/CsvTypeProvider/TypeProviderLibrary/TypeProviderLibrary.fsproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/FableApp/FableApp.fsproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/ReferencesOrder/ReferencesOrder.fsproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/SwaggerProviderCSharp/CSharpLibrary/CSharpLibrary.csproj)
- End-of-life runtime: .NET net6.0 (rider-fsharp/src/test/testData/solutions/SwaggerProviderCSharp/SwaggerProviderLibrary/SwaggerProviderLibrary.fsproj)
- …and 9 more
Changes since last survey
- 38 commits — 35 feature/other, 3 fixes
By area
- ReSharper.FSharp/test — 15 commits
- ReSharper.FSharp/src — 10 commits
- rider-fsharp/src — 9 commits
- rider-fsharp/build.gradle.kts — 1 commit
- rider-fsharp/gradle.properties — 1 commit
- rider-fsharp/injections — 1 commit
- rider-fsharp/parserTest — 1 commit
Notable commits
- fix: RIDER-141156 FSharpLexer: fixes for interpolated strings
- fix: RIDER-144197 rider-maui: fixed debugging of iOS CoreCLR applications for all sessions
- fix: RIDER-144617 Parameter info: fix named args presentation, add filtering
- change: CPP-51104 [radler]: MSBuild project kinds require IMsBuildZone
- change: IJPL-256595 Build the Rider plugins with Kotlin 2.4.20
- change: MRI-5868 [dotnet] Updating DistributedCache to 1.2.20261111.271, which keeps remote cache uploads enabled when an entry is too large
- change: RIDER-106262 Project model: support LinkPase
- change: RIDER-117725 Tooltips: show tooltips for _ patterns
- change: RIDER-126343 RIDER-130475 Psi: mark interface extension parts as augmentations
- change: RIDER-139534 Code completion: add missing null checks
- change: RIDER-144128 rider-maui: update ICorDebug packages, supporting debugging of MacCatalyst (and tvOS)
- change: RIDER-144447 Bind: add PreferQualifiedReference setting
- change: RIDER-144447 Completion/import: check the containing module for union cases
- change: RIDER-144447 Completion/import: use scopes of the reparsed file when checking opened modules
- change: RIDER-144447 Import: allow to never import specific symbols
- change: RIDER-144565 Psi: better features support for unfinished strings
- change: RIDER-144624 [rider] extract C# syntax into intellij.rider.languages.psi module
- change: RIDER-144885 rider-maui: launch MacCatalyst debugging in client mode in order to avoid problems with sandbox restrictions
- change: RIDER-17284 RIDER-19094 RIDER-36201 Project model: support nesting
- change: RIDER-38069 RIDER-99079 RIDER-99932 RIDER-129314 Project model: better support for implicit and multi-target includes
- …and 18 more
Architecture
- Unchanged — 3 containers · 1 contexts · 0 edges
Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
JetBrains/resharper-fsharp was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.
About this page
- The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
- Measured at commit 5a9f28b8a73247d7757bba2012df531bcb26a0df — the exact code this score is about.
- Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
- Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-b8b1a43ae4c3.