JetBrains/resharper-fsharp

This system is the F\# language support plugin for JetBrains Rider, providing a comprehensive IDE experience for F\# development. It integrates with the F\# Compiler Service to deliver features such as code completion, refactoring, debugging, and static analysis. The plugin also manages external tools like Fantomas for code formatting and F\# Interactive for interactive scripting, ensuring a cohesive development environment.

71 changes.

This period focused on establishing the initial F\# backend support for JetBrains Rider, involving a significant architectural overhaul that replaced legacy parsing and PSI infrastructure with a modern, modular plugin structure. Concurrently, the team extensively expanded the test suite to cover code completion, navigation, refactoring, and syntax highlighting, ensuring the new implementation was robust and complete.

76 changes.

This period was dominated by the addition of extensive test data and unit tests for the F\# language plugin. The work focused on validating code actions, quick fixes, and daemon analysis features, ensuring correct behavior for a wide range of F\# syntax and semantics.

108 changes.

This period focused on completing the F\# plugin's feature set by implementing core IDE integrations such as code completion, refactoring, debugging, and static analysis. The work also involved significant architectural improvements, including the introduction of an out-of-process type provider host and a comprehensive test suite migration to JUnit 5.

28 changes.

This period focused on deepening F\# integration across the IDE, introducing new features such as sticky scrolling, AI-driven syntax checking, and enhanced debugging capabilities for async workflows. Significant effort was also dedicated to expanding test coverage for lexer, parser, and intention actions, alongside implementing specific behavioral changes like disabling context navigation for functional members.

Introduced a new F\# identifier highlighting that provides status bar tooltips for identifiers in the F\# language. The implementation includes the FSharpIdentifierHighlighting class to manage the highlighting and a corresponding FSharpIdentifierTooltipProvider to supply the tooltip content, enabling users to see detailed information about identifiers directly in the editor.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/Highlightings · medium confidence

New F\#-specific implementations for the AI Core infrastructure have been added, enabling syntax error checking and file summarization for F\# code. This includes a new FSharpBackendSyntaxErrorChecker that translates F\# compiler diagnostics into backend errors, a FSharpFileSummarizer that generates structured summaries of F\# files (including namespaces, modules, types, and members), and an FSharpModuleLanguageDetailsProvider to identify F\# modules for AI context.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/AICore · high confidence

The F\# plugin now supports code folding in the editor. Users can collapse and expand blocks of code such as imports, attributes, comments, XML documentation, and members, with each block type mapped to the appropriate folding attribute. This brings the F\# experience in line with other languages by providing a dedicated folding processor that identifies and manages these regions.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Foldings · high confidence

Users can now use the 'Disable Warning' intention on F\# code, allowing them to suppress specific compiler or ReSharper diagnostics via generated \#nowarn or \#warnon comments.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/DisableWarning · high confidence

Introduced new providers to support F\# block and line comment actions, enabling proper comment insertion and formatting. Additionally, added a code completion context provider and elements items provider for F\# documentation comments, allowing IntelliSense to function correctly inside XML-style doc comments.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Comment · high confidence

The F\# plugin now supports external annotations for F\# code. A new \FSharpAnnotatedMembersCacheProcessor\ scans F\# files to identify annotated members and types, while \FSharpExternalAnnotationsFileProvider\ loads external annotation files from the plugin's 'annotations' directory. This enables IDE features like navigation and refactoring for F\# code that uses external annotations.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Annotations · high confidence

Introduced default file templates for F\# projects and files, enabling users to quickly generate new source files, signature files, scripts, and type files within F\# projects. The change adds a new \FileTemplates.fs\ file defining scope providers and a \FileTemplates.xml\ file containing the template definitions for these F\#-specific templates.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/FileTemplates · high confidence

A new F\# lexer implementation (\_FSharpLexer.flex) has been added to the rider-fsharp/lexer module. This introduces the core lexical analysis logic for F\# syntax within the Rider IDE, supporting features like interpolated strings and nested comment tracking.

rider-fsharp/lexer · high confidence

Introduced a new F\# parameter info implementation in the FSharp.Psi.Features module, providing detailed parameter information for F\# code. This includes support for parameter groups, optional parameters, XML documentation, and handling of tuple expressions and patterns in function calls.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/ParameterInfo · high confidence

Users can now use postfix templates in F\# code completion to quickly generate common code patterns. New templates include 'for' to iterate over enumerable collections, 'let' to introduce variable bindings, 'match' for pattern matching, 'new' to create object expressions or record instances, 'not' to apply the not function, and 'with' to copy and update record fields. These templates expand selected expressions into the corresponding F\# syntax, streamlining the coding process.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/PostfixTemplates · high confidence

The F\# plugin now provides specific semantic highlighting for F\# symbols (such as records, structs, unions, and members) within the IDE daemon. This new utility class maps F\# entity types to corresponding highlighting attributes, enabling the IDE to visually distinguish between different F\# constructs like namespaces, enums, delegates, modules, and various member types in the editor.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon · medium confidence

Introduced a new test host component for the F\# plugin that exposes diagnostic and debugging capabilities. The host registers handlers for retrieving project options, FCS project stamps and references, assembly reader dumps, Fantomas version and run options, type provider runtime information, and culture settings. It also provides utilities for formatting notifications and updating assembly reader settings, enabling deeper inspection of the F\# plugin's internal state during testing.

ReSharper.FSharp/src/FSharp/FSharp.Tests.Host · high confidence

New classes have been introduced in the F\# PSI cache2 implementation to represent compiled F\# types and modules. This includes \FSharpCompiledClass\, \FSharpCompiledDelegate\, \FSharpCompiledEnum\, \FSharpCompiledInterface\, \FSharpCompiledStruct\, and \FSharpCompiledModule\, along with their base classes and extension member handling. These classes provide the underlying structure for representing F\# types, modules, and extension members in the compiled code model, enabling the IDE to understand and navigate F\# symbols from compiled assemblies.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2/Compiled · high confidence

The F\# plugin now exposes compiler-generated members for F\# types in the PSI, including constructors, methods (such as CompareTo, Equals, GetHashCode, and ToString), properties (such as IsCase for union cases), and tags for union cases. This allows the IDE to provide better code analysis, navigation, and refactoring support for F\# specific language constructs.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement/CompilerGenerated · high confidence

The F\# plugin now provides enhanced code insight features, including context-sensitive highlighting for type parameters (matching braces/angles) and usage highlighting for identifiers and active patterns. This adds new \FSharpTypeParametersMatchingBracesContextHighlighter\ and \FSharpUsagesContextHighlighter\ classes to the daemon features, improving how the IDE visually indicates type parameter boundaries and symbol usages in F\# code.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/ContextHighlighters · high confidence

Users can now run 'Reformat code' and 'Remove code redundancies' on F\# files via the Code Cleanup tool. The reformat action supports both selection and whole-file operations, utilizing the ReSharper C\#-style formatter for selections and delegating to the Fantomas tool for full-file formatting, with settings mapped from .editorconfig. Additionally, the 'Remove unused opens' cleanup module is available to optimize imports on save.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCleanup · high confidence

The plugin now provides dedicated logic for these refactorings in the F\# language. The 'Introduce Variable' and 'Inline Variable' refactorings are implemented to handle F\#-specific syntax, such as \let\ and \use\ bindings, pattern matching, and nested record field updates. The 'Rename' refactoring is extended to support F\# elements, including anonymous record fields, generated constructor parameters, and union cases. These changes ensure that standard refactoring tools work correctly within the F\# codebase.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Refactorings · high confidence

The F\# plugin now supports AI-assisted documentation generation. New components, including FSharpDocGenSupportProvider and FSharpCodeSetNodesFactory, have been added to the AI subsystem, allowing the system to generate and update XML documentation comments for F\# declarations. This enables AI features to interact with F\# codebases for documentation purposes.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/AI · high confidence

The F\# plugin now includes core debugger infrastructure, introducing four new components in the debugger package: FSharpBreakpointVariantsProvider for managing breakpoint locations, FSharpDebuggerLocalSymbolProvider for resolving local variables, FSharpExpressionEvaluationInfoProvider for evaluating expressions in the watch/locals windows, and FSharpSourceCallableExpressionsProvider for identifying callable expressions. These additions allow users to set breakpoints, inspect local values, and evaluate F\# expressions during debugging sessions.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Debugger · high confidence

The F\# plugin now supports sticky scrolling for various language constructs, including nested modules, type declarations, members, let bindings, match expressions, and if/elif/else expressions. This allows users to keep headers or key code sections visible while scrolling through long F\# files.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/StickyLines · high confidence

The F\# debugger now supports stepping through F\# async workflows and tasks, allowing developers to navigate through asynchronous code more naturally. Additionally, the debugger provides improved handling of return values for F\# functions, including support for Smart Step Into, which lets users skip over methods they don't need to debug. The debugger also filters out hidden symbols and unit return values to reduce noise in the call stack and variable views.

ReSharper.FSharp/src/FSharp.Debugger/src · high confidence

The F\# plugin now provides more granular Find Usages categorization, distinguishing between partial applications, recursive invocations, copy-and-update expressions, and other F\#-specific patterns. Additionally, a new search capability allows finding file paths referenced in F\# source code, and record constructors can be searched by their field names.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Search · high confidence

The F\# Interactive console now supports command history navigation using the Up and Down arrow keys, allowing users to recall and edit previous commands. Additionally, the console view now displays line numbers for the last submitted code block, and the command history is accessible via a dedicated action in the UI. These changes enhance the interactive development experience by making it easier to reuse and modify previous FSI commands.

rider-fsharp/src/main/java/com/jetbrains/rider/plugins/fsharp · high confidence

The F\# Interactive (FSI) console now features a command history that allows users to navigate through previous commands. Output rendering has been improved with syntax highlighting and gutter icons to distinguish between normal output, errors, and user input. Additionally, line numbers are displayed for the last submitted command, and the console editor includes useful tools like an input separator gutter content provider. These changes enhance the interactive development experience by providing better feedback and navigation within the FSI console.

protocol · high confidence

The F\# PSI cache implementation has been expanded with new cache part classes for various F\# language constructs, including classes, interfaces, enums, delegates, exceptions, modules, and namespaces. These new parts handle serialization, member presence flags, type parameters, and extension members, enabling the cache to store and retrieve detailed structural information about F\# types and modules for faster and more accurate code analysis.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2/Parts · high confidence

The F\# plugin now includes a dedicated code formatter. This change introduces the \FSharpCodeFormatter\ and \FSharpFormatterInfoProvider\ classes, which implement formatting logic for F\# source files. The \FSharpFormatSettingsKey\ class defines the configuration options for this formatter, including settings for spacing, line breaks, wrapping, and indentation specific to F\# syntax. This enables users to format F\# code consistently within the IDE.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/CodeFormatter · high confidence

The F\# plugin now supports generating overrides and missing members for F\# code. This change introduces new files (FSharpGeneratorContext.fs, GenerateOverrides.fs, GenerateProvider.fs) that implement the core logic for creating member declarations, handling base calls, and managing type annotations. Users will see generated code for overriding methods and implementing missing members in F\# classes and objects.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Generate · medium confidence

Added initial F\# language support in the Rider plugin, including a dummy parser, lexer, syntax highlighting, and file type definitions for F\#, F\# Script, and F\# Signature files. The change also introduces F\# project templates for class libraries and console applications, and implements language injection for SQL within F\# string literals.

rider-fsharp · high confidence

The F\# plugin now uses a custom metadata reader to parse F\# signature data from assemblies, enabling the IDE to understand F\# types and modules from compiled assemblies. Additionally, a new cache tracks \AutoOpen\ modules to improve how the IDE resolves and imports F\# types and modules, ensuring that auto-opened namespaces are correctly recognized during code analysis and completion.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Metadata · high confidence

The F\# plugin is now bundled with Rider, meaning users will have F\# support available out of the box without needing to install it separately. This change includes the main FSharp plugin, the F\# debugger, Fantomas integration, and Type Providers as bundled components.

ReSharper.FSharp/src/FSharp.RiderPlugin · high confidence

The F\# plugin now includes zone markers to declare dependencies on the IFSharpPluginZone, ensuring proper initialization order and isolation within the ReSharper host. Additionally, a ReadLockCookie utility is introduced to manage read lock cookies for F\# PSI services, likely improving thread-safety and concurrency handling in the F\# language service.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src · high confidence

The F\# plugin introduces a comprehensive suite of new static analysis analyzers to detect code issues and redundancies. These include checks for redundant expressions (parentheses, application, new), patterns (as, list cons), and attributes. The diff also adds analyzers for lambda simplification, interpolated strings, and recursion detection, alongside utilities for language level and F\# core version detection.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/src · high confidence

Added new files to the F\# plugin's common layer, including a resource strings file for type hint descriptions, a FcsCheckerService and related checker extensions for managing the F\# compiler service, and metadata models for compiled types. These changes introduce the core infrastructure for displaying type hints and handling F\# project checking.

ReSharper.FSharp/src/FSharp/FSharp.Common · high confidence

Code completion for F\# scripts now supports resolving NuGet package references and local file/directory paths within hash directives (e.g., \#r, \#load). The update introduces new providers for script references and FCS-based lookup items, enabling richer suggestions for assembly and script paths, while also refining how symbols are presented and filtered.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion · high confidence

The repository now includes the initial implementation of F\# language support for JetBrains Rider, comprising a .NET-based backend (ReSharper.Host plugin) and a Kotlin/Java-based frontend (IntelliJ Platform plugin). This change introduces the core infrastructure for F\# development, including build instructions, release notes, and configuration files (.editorconfig, .gitattributes, .gitignore) to support the new plugin architecture.

(repo-wide) · high confidence

Adds the F\# plugin's implementation for the code structure tree, enabling the display of modules, types, members, and let bindings in the IDE's project view. It also introduces a 'Goto Class Member' provider for F\# types and a run marker provider that highlights static methods and entry points, allowing users to run F\# scripts and methods directly from the editor.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeStructure · high confidence

Added new files in the F\# plugin's \Injected\ directory to enable language injection for F\# code. This includes \FSharpInjectionTargetsFinderFactory\ and \FSharpInjectionUtil\ to detect string literals and attributes for HTML, CSS, SQL, JS, JSON, and XML injections. Additionally, \FSharpRegexNodeProvider\ and \FSharpRegexProviders\ are introduced to support .NET Regular Expression injection, while \FSharpLiteralInjectionTarget\ handles literal injection targets. These changes allow the F\# plugin to recognize and inject syntax highlighting and validation for embedded languages and regex patterns within F\# source files.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Injected · high confidence

Adds new F\# language service implementations to the IDE, including breadcrumbs, icon providers, element presenters, and import type helpers. This enables the IDE to correctly display F\# specific icons, handle copy/paste behavior, and provide quick definitions and breadcrumbs for F\# code.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/LanguageService · high confidence

The F\# plugin now includes a dedicated lexer and preprocessor implementation to handle conditional compilation directives (such as \#if, \#else, \#endif, and \#warnon) and other preprocessor logic. This change adds the core parsing components—FSharpLexer, FSharpPreprocessedLexer, FSharpPreprocessor, and associated token types—which enable the IDE to correctly parse and understand F\# source code containing conditional compilation symbols and compiler warnings directives.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Parsing · high confidence

Added the F\# typing assist implementation (FSharpTypingAssist.fs) which provides intelligent code formatting, indentation, and bracket handling for F\# source files. This includes logic for handling single-line expressions, multiline strings, and auto-inserting brackets based on user settings. Additionally, new utility files (ReadLockCookieUtil.fs, ZoneMarker.fs, ZoneMarkerServices.fs) were introduced to support the plugin's architecture and zone-based initialization.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src · high confidence

Added three new files to the F\# PSI implementation to support parsing and navigating XML documentation comments for F\# code. This includes a language definition for F\# XML doc comments, a PSI class to manage the XML structure of these comments, and a navigator to locate doc comment blocks within the syntax tree.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DocComments · high confidence

Added a new out-of-process host for F\# type providers, including the \TypeProvidersExternalProcess\ and \TypeProvidersConnection\ classes to manage the external process lifecycle, alongside \TcImportsHack\ to facilitate data transfer between processes. This change enables the F\# plugin to run type providers in a separate process, improving stability and allowing support for .exe executables in the monorepo build environment.

ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src · high confidence

Added a new set of model classes and interfaces in the F\# Type Providers Protocol to act as proxies for F\# provided types, assemblies, namespaces, and reflection-like objects (constructors, events, fields, methods, parameters, and properties). These new files, including ProxyProvidedAssembly, ProxyProvidedConstructorInfo, ProxyProvidedEventInfo, ProxyProvidedFieldInfo, ProxyProvidedMethodInfo, ProxyProvidedNamespace, and their corresponding 'WithContext' variants, enable the plugin to interact with type provider metadata through a remote protocol, supporting features like lazy loading and cache invalidation for generated types.

ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Models · high confidence

Added a new caching subsystem for F\# type providers, including a generic \ProvidedEntitiesCacheBase\ and specific caches for provided types, assemblies, and abbreviations. The \TypeProvidersContext\ now manages these caches, enabling the IDE to store and retrieve generated types, assemblies, and abbreviations more efficiently, with support for batch retrieval and invalidation.

ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Cache · high confidence

The F\# plugin now utilizes the new Cache2 caching system for F\# PSI elements. This change introduces a new \FSharpCacheProvider\ and associated classes (such as \FSharpClass\, \FSharpModule\, and \FSharpUnionCaseClass\) to handle the serialization and deserialization of F\# type and module declarations. This enables more efficient caching of F\# project model data, improving performance and stability for features like completion and navigation.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Cache2 · high confidence

The F\# plugin now exposes a comprehensive set of new interfaces and helper classes in the PSI tree layer, including navigators for expressions (e.g., AppExpr, BinaryAppExpr, ConditionOwnerExpr), declarations (e.g., IAbstractMemberDeclaration, IAccessorDeclaration, IModuleDeclaration), and utility classes for resolving references and handling sand-boxed nodes. These additions provide a more structured and consistent way to traverse and inspect the F\# abstract syntax tree, enabling better code analysis, refactoring, and completion features for F\# code.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Tree · high confidence

The F\# plugin now includes a comprehensive new subsystem for detecting, configuring, and launching the F\# Interactive (FSI) environment. This adds a settings page where users can choose between automatic detection of the FSI tool, manual selection of a specific FSI executable path, or a custom path. Users can also configure launch arguments, enable shadow copying of referenced assemblies to prevent file locking, specify the F\# language version for scripts, and adjust editor caret movement and recent command execution behaviors. The system supports multiple providers (Visual Studio, Mono, NuGet packages, etc.) to locate the FSI runtime.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Fsi · high confidence

Added several new utility classes in the F\# PSI layer to improve code analysis and symbol resolution. FSharpArgumentsUtil and FSharpExpressionUtil provide helpers for identifying named arguments, simple value expressions, and traversing outermost parent expressions. FSharpPatternUtil and FSharpParameterDeclarationUtil handle pattern matching logic and parameter declaration extraction. FcsSymbolMappingUtil and FcsTypeMappingUtil map F\# Compiler Service symbols and types to PSI elements, while FSharpNamesUtil handles name resolution and escaping. These utilities support more accurate refactoring, completion, and navigation features for F\# code.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Util · high confidence

Added new utility classes and exception types for the F\# Type Providers protocol. This includes \ExecutionWrapper\ for safe execution of type provider operations, custom exceptions (\ProvidedTypeException\, \TypeProvidersInstantiationException\) for error handling, and utility classes (\PrimitiveTypesBoxer\, \ProvidedAssembliesComparer\, \ProvidedCustomAttributeProvider\, \ProvidedTypesComparer\, \TypeProviderComparer\) that handle serialization, comparison, and attribute retrieval for F\# type providers.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Injections, ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Exceptions, ReSharper.FSharp/src/FSharp/FSharp.TypeProviders.Protocol/src/Utils · high confidence

The F\# language plugin introduces a suite of new code completion rules in the \CodeCompletion/Rules\ directory, including \FSharpKeywordsRule\, \FSharpRelevanceRule\, \FilterFcsItemsRules\, \GenerateLambdaRule\, \GenerateMatchExprPatternsRule\, \ImportExtensionMemberRule\, \ImportModuleMemberRule\, \ImportStaticMemberRule\, \ImportTypeElementRule\, \LocalValuesRule\, and \NameSuggestionRule\. These files implement specific logic for F\# syntax, such as inserting keywords with appropriate suffixes (quotes, spaces), filtering and reordering completion items based on context (e.g., distinguishing between local variables, methods, and types), generating lambda expressions and match patterns, and handling imports for module members, static members, and type elements. This adds comprehensive support for F\#-specific completion behaviors that were previously missing or handled differently.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeCompletion/Rules · high confidence

Added a suite of new F\# refactoring intentions and context actions to the IDE. Users can now convert dot-lambda expressions to lambda expressions, partially applied functions to lambda expressions, and match lambda expressions to parameters. Additional quick fixes include converting \if\ to \elif\ and vice versa, inverting \if\ conditions, negating \if\ and \while\ conditions, and deconstructing patterns. The update also introduces actions to rename files to match type or module names, convert \let\ bindings to \use\ bindings, and disable or restore compiler warnings using both ReSharper and native F\# directives (\\#nowarn\/\\#warnon\).

ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/Intentions · high confidence

Users can now configure F\# formatting preferences directly within the IDE. A new 'Formatting Style' page allows fine-grained control over indentation, spacing, and line-wrapping rules for F\# code. Additionally, a 'Fantomas' settings page lets users choose between using the bundled Fantomas formatter, a global .NET tool, or a local \dotnet-tools.json\ manifest, with validation and notifications for version compatibility and availability.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/CodeStyle · high confidence

The F\# plugin now provides a comprehensive set of new classes in the \ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement\ directory to represent various F\# language constructs within the PSI (Program Structure Interface). This includes base classes like \FSharpDeclaredElementBase\ and \FSharpMemberBase\, as well as specific implementations for constructors (\FSharpConstructorBase\), methods (\FSharpFunctionBase\, \FSharpMethod\), properties (\FSharpCompiledPropertyBase\, \FSharpProperty\), fields (\FSharpFieldBase\, \FSharpFieldProperty\), events (\FSharpCliEvent\), and parameters (\FSharpMethodParameter\). These changes enable more accurate code analysis, navigation, and refactoring support for F\# code in the IDE.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement · high confidence

The F\# plugin now includes a comprehensive set of error and warning highlightings for the F\# language, including type equations, unit type expectations, incomplete matches, and various redundancies. These highlightings are backed by quick fixes such as converting to use bindings, adding missing patterns, and removing redundant code, providing users with immediate ways to resolve common F\# compiler issues directly in the editor.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Daemon · high confidence

The F\# plugin introduces a suite of new quick-fixes to automatically resolve common compiler errors and warnings. Users can now automatically add missing patterns in match expressions, convert let bindings to use bindings, add parentheses to resolve type errors, and fix missing type annotations. Additional fixes allow adding the 'Extension' attribute, generating interface members, and renaming unused values with an underscore prefix. These changes improve the developer experience by providing immediate, automated solutions for frequent F\# syntax and type-checking issues.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src/QuickFixes · high confidence

Users can now rearrange the order of various F\# language constructs, including tuple patterns, or patterns, and match clauses, using the IDE's code rearrangement features.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/RearrangeCode · high confidence

The legacy F\# lexer implementation and its associated token type definitions have been removed from the codebase. Specifically, the \FSharpFakeLexer\, \FSharpLexer\, \FSharpTokenInfoEx\, \FSharpTokenNodeType\, \FSharpTokenType\ (including generated types and XML configuration) are all deleted. This cleanup removes the old parsing infrastructure that was likely superseded by a new F\# backend or cache provider, as indicated by the surrounding commit history.

ReSharper.FSharp/src/Psi.FSharp/src/Parsing · high confidence

The F\# Type Providers module now uses its own Directory.Build.props and PackagesLock.targets files to manage dependencies and build properties. This isolates the build configuration for the Type Providers subplatform, ensuring that package versions (such as FSharp.Core, JetBrains.Annotations, and JetBrains.FSharp.Compiler.Service) are managed independently from the rest of the F\# plugin.

ReSharper.FSharp/src/FSharp.TypeProviders.Host · high confidence

The F\# plugin's build and configuration infrastructure has been significantly reorganized. A new \Directory.Build.props\ file centralizes build properties, including setting C\# language version to 12 and enabling assembly signing. The solution file (\ReSharper.FSharp.sln\) has been updated to reflect a new, more granular project structure with multiple F\# and C\# projects organized under 'src' and 'test' folders. Additionally, a \GitHubActions.targets\ file was added to manage assembly copy-local paths, and a \.gitignore\ update excludes generated and Rider-specific files.

ReSharper.FSharp · high confidence

The F\# parsing layer has been refactored to use new, dedicated tree builder classes: FSharpImplTreeBuilder for implementation files, FSharpSigTreeBuilder for signature files, and a shared FSharpTreeBuilderBase. These classes handle the translation of the F\# Compiler Service (FCS) syntax tree into the ReSharper PSI tree. The refactoring introduces utility functions in FcsSyntaxTreeUtil to handle specific syntax patterns, such as extracting attributes and XML documentation from complex member definitions like get/set properties. This change reorganizes the parsing logic to better separate concerns between file types and provides a more robust foundation for future F\# language support.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Parsing · high confidence

The F\# plugin's backend and host components are split into distinct, isolated projects (FSharp.Debugger, FSharp.Fantomas.Host, FSharp.RiderPlugin, FSharp.TypeProviders.Host, and various FSharp.\* modules) to separate internal build artifacts from independent builds. This restructuring ensures that each subplatform (e.g., the Fantomas host, type providers, and debugger) is built and packaged independently, improving build stability and allowing for more granular updates to dependencies like FSharp.Core and JetBrains SDKs.

(dependencies) · high confidence

The F\# plugin now includes dedicated resource files (Strings.resx and Strings.Designer.fs) to support internationalization of user-facing text. This adds translations for the 'Signatures' options page title, headers for 'Top-level bindings and type members', 'Local bindings', 'Pipe operators', and 'Other patterns' settings. It also provides strings for the 'F\# Inferred types' highlighting provider ID, tooltip text for copying inferred types, and descriptions for showing return types in pipe chains and hiding them on the same line.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Daemon/Resources · high confidence

Users can now disable or restore F\# inspections using \#nowarn and \#warnon directives, in addition to the existing comment-based suppression options. New menu items include 'Disable in file with \#nowarn' and 'Disable once with \#nowarn', alongside the previous comment-based actions.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/Resources · high confidence

The F\# plugin now provides color highlighting for the MonoGame \Color\ type. This is achieved by introducing \FSharpVisualElementFactory\ and \IFSharpElementFactory\ in the PSI features utility layer, enabling the IDE to recognize and colorize references to MonoGame's \Color\ struct and its associated properties and constructors.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/Util · high confidence

A new intention provider for specifying types has been added to the F\# plugin. This component, which creates bulb menu items for type specification, is explicitly marked as deadlock-safe to ensure thread safety during instantiation.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Intentions · high confidence

A new component, ProvidedAbbreviationTypePartInvalidator, has been introduced in the F\# PSI module. This class registers as a solution component and subscribes to the symbol cache's OnBeforeTypePartRemoved event. Its purpose is to detect when type parts are removed and, if they are type abbreviations, mark them as dirty in the type providers manager. This ensures that cached type information for F\# type providers is properly invalidated when the underlying symbols change or are removed.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/TypeProviders · medium confidence

The FSharp.TypeProviders.Host subplatform now includes build steps to copy the tploader.runtimeconfig.json files for both Unix and Windows, and to install the application .exe.config file. Additionally, build constants for the FSharp.TypeProviders.Host subplatform are explicitly defined.

ReSharper.FSharp/src/FSharp.TypeProviders.Host/BuildScript · medium confidence

The F\# plugin now disables context navigation for functional members. This is achieved by introducing a new utility class, FSharpContextNavigationUtil, which defines which elements support no-hierarchy navigation, and three new context search classes (FSharpBaseContextSearch, FSharpInheritorsContextSearch) that explicitly return false for availability, effectively turning off these navigation features for the specified F\# member types.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Navigation · medium confidence

The F\# plugin now supports smarter text selection for various F\# language constructs, including identifiers, type references, pattern matching clauses, bindings, and interpolated strings. This change improves the user experience by automatically extending selections to encompass related semantic elements, such as selecting the full declaration or attribute context when a user selects a specific part of the code.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/ExtendSelection · high confidence

The F\# Debugger module now includes a dedicated subplatform definition and package lockfiles. The Subplatform.Root file registers the F\# debugger with the Rider backend, the Libs debugger library, and the ReShaper F\# backend model. A new PackagesLock.targets file pins specific versions of dependencies including JetBrains.Annotations (2026.2.0), JetBrains.ICorDebug (2.0.20260715.131), and Newtonsoft.Json (13.0.3), ensuring consistent package resolution for the debugger component.

ReSharper.FSharp/src/FSharp.Debugger · medium confidence

The F\# Fantomas integration has been refactored to run in a separate out-of-process host. This change introduces new components including FantomasAssemblyResolver, FantomasCodeFormatter, and FantomasEndPoint, which handle assembly resolution, code formatting, and protocol endpoints respectively. The integration now supports multiple Fantomas versions (4.5, 4.6, 5.0, 6.0, 7.0.3) with version-specific code paths for F\# compiler APIs and Fantomas APIs. The formatter now supports format selection operations and provides version information through the protocol.

ReSharper.FSharp/src/FSharp.Fantomas.Host/src · medium confidence

The F\# PSI (Program Structure Interface) layer has been restructured and expanded. New interfaces have been added to represent F\#-specific elements, including IFSharpDeclaredElement, IFSharpParameterOwner, IFSharpProperty, and IFSharpFunction, among others. A new FSharpParameterIndex struct and FSharpTreeNodeExtensions class have been introduced to support F\#-specific parameter handling and tree node operations. The FSharpTreeBuilder and related tree-building components have been updated to support new F\# language features. Additionally, the ZoneMarker has been updated to require IFSharpPluginZone instead of ILanguageFSharpZone, indicating a shift in plugin zone management. These changes provide a more robust and feature-complete PSI layer for F\# support.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src · medium confidence

The F\# plugin's \Util\ directory has been reorganized into a set of new, specialized utility classes to support various IDE features. These include \Deconstruction.fs\ for handling pattern deconstruction, \FSharpAttributesUtil.fs\ for managing attribute lists, \FSharpAutoOpenUtil.fs\ for auto-open module resolution, \FSharpBindUtil.fs\ for binding symbols to references, \FSharpChangeTypeHelper.fs\ for type change quick-fixes, \FSharpCodeCompletionContext.fs\ and \FSharpCompletionUtil.fs\ for code completion logic, \FSharpExpectedTypesUtil.fs\ for type inference, \FSharpExpressionUtil.fs\ for expression analysis, \FSharpExtensionMemberUtil.fs\ for extension member resolution, and \FSharpImportStaticMemberUtil.fs\ for static member imports. These changes improve the internal structure and capabilities of the F\# language support.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/src/Util · high confidence

The F\# plugin's core components have been reorganized into the FSharp.ProjectModelBase directory, introducing new classes for managing assembly reading, file system shims, and read-lock request queuing to improve stability and cancellation handling. The F\# project file types have been updated to explicitly define default build actions (COMPILE for standard F\# files, NONE for scripts) and adjust supported file extensions. Additionally, new compiled icon resources have been added for F\# modules, usage partial applications, and extension overlays, ensuring consistent visual representation across different UI themes.

ReSharper.FSharp/src/FSharp/FSharp.ProjectModelBase · high confidence

The FSharp plugin's zone markers and lock cookie utilities have been corrected to ensure proper plugin initialization and thread safety. Specifically, the zone marker for the FSharp plugin is now correctly defined to require the IFSharpPluginZone, and a ReadLockCookie type alias has been added to support read-locking mechanisms within the PSI intentions layer.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Intentions/src · medium confidence

The F\# plugin now uses a dedicated search infrastructure to improve code search and usage finding. A new search filter filters out irrelevant source files and private members, while a custom reference searcher and processor handle F\#-specific naming and element resolution. The factory also maps related declared elements (such as union cases and generated parameters) and provides navigation targets, ensuring that find-usages and rename operations correctly traverse F\# constructs like unions, active patterns, and generated members.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Searching · high confidence

The F\# lexer now supports raw interpolated strings, allowing users to write string literals with embedded expressions without escaping braces. Additionally, the lexer correctly handles escaped braces within interpolated strings, ensuring that characters like \{\ and \}\ are properly recognized and do not break parsing. This change enhances the accuracy of the F\# language plugin by fixing previous issues with quote and brace consumption.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Parsing/Lexing · medium confidence

The F\# plugin now correctly determines source accessibility for F\# type elements, ensuring that file-private and internal visibility rules are properly enforced. Additionally, the plugin improves handling of generated members, such as structural equality and comparison methods, and refactors property handling for indexed accessors. These changes enhance the accuracy of code analysis and refactoring tools for F\# projects.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl · medium confidence

The F\# plugin now ensures that the F\# Core XML documentation file is packaged and installed with the product, which fixes cases where tooltips would fail to appear. Additionally, F\# annotation files are now explicitly copied and included in the plugin package to support better IDE integration.

ReSharper.FSharp/src/FSharp/BuildScript · high confidence

The F\# language service for TODO items has been updated to correctly identify multiline block comments (delimited by (\* and \*)) as such, rather than treating them as identifiers or other token types. This ensures that TODO markers within multiline comments are properly recognized and processed by the IDE's TODO list features.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/src/TodoItems · high confidence

The F\# plugin build script now explicitly packages the Fantomas host's runtime configuration files (Fantomas.Host.unix.runtimeconfig.json and Fantomas.Host.win.runtimeconfig.json) and the JetBrains.ReSharper.Plugins.FSharp.Fantomas.Host.deps.json dependency file. This ensures these critical runtime files are correctly included in the final plugin distribution, allowing the Fantomas host to function correctly at runtime.

ReSharper.FSharp/src/FSharp.Fantomas.Host/BuildScript · high confidence

The F\# plugin now uses a centralized package lock file to manage dependencies. A new \Directory.Build.props\ file defines the path to the lock file, which is implemented in \PackagesLock.targets\ to pin specific versions of key libraries such as Fantomas, FSharp.Core, JetBrains.Annotations, and NuGet components. This change ensures consistent and reproducible builds by explicitly defining the versions of these dependencies.

ReSharper.FSharp/src/FSharp · high confidence

The F\# type provider host has been refactored into an out-of-process architecture. A new caching layer (IProvidedCache, MetadataEntitiesCache, etc.) manages the lifecycle and sharing of type provider metadata across multiple instances. Dedicated host classes (e.g., ProvidedTypesHost, ProvidedMethodInfosHost) now handle remote requests for types, methods, and assemblies, converting internal models into RD protocol models. This change improves stability and isolation by moving type provider execution into a separate process.

ReSharper.FSharp/src/FSharp.TypeProviders.Host/FSharp.TypeProviders.Host · high confidence

The F\# plugin's inter-process communication layer was updated with new protocol models to support F\# Interactive session management, out-of-process Type Provider resolution, and Fantomas code formatting. These changes introduce the necessary data structures and remote calls to manage FSI sessions, handle type provider metadata, and execute formatting requests, enabling the IDE to communicate effectively with these external tools.

rider-fsharp/protocol · high confidence

The Fantomas host subplatform has been restructured to run on .NET 8, as indicated by the new runtime configuration files (Fantomas.Host.unix.runtimeconfig.json and Fantomas.Host.win.runtimeconfig.json) specifying Microsoft.NETCore.App and Microsoft.WindowsDesktop.App version 8.0.0. The subplatform now includes a PackagesLock.targets file that explicitly pins versions for Fantomas.Core, Fantomas.FCS, FSharp.Core, and various JetBrains and Microsoft packages. Additionally, a Directory.Build.props file was added to manage package lock file paths, and the Subplatform.Root file defines the new subplatform's references to Rider.Backend, FSharp, and BackendModel.

ReSharper.FSharp/src/FSharp.Fantomas.Host · high confidence

The F\# plugin introduces new base classes, FSharpDaemonStageBase and FSharpDaemonStageProcessBase, to standardize how daemon stages filter files and create processes. This refactoring simplifies stage implementation by handling common logic for visible document and signature file checks, and ensures that stages correctly specify their required highlighting types. The existing HighlightIdentifiersStage is updated to inherit from these new base classes, which should improve consistency and performance in the F\# code analysis pipeline.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Features/Daemon/Stages · high confidence

The Fantomas integration has been refactored to support .exe executables in addition to .dll files, allowing the plugin to launch the external process using the internal .NET runtime. This change introduces new protocol classes (FantomasConnection, FantomasProcess, FantomasProcessFactory) and a version attribute to manage the external process lifecycle, environment variables, and runtime configuration paths, ensuring the plugin correctly locates and launches the Fantomas host binary from the plugin's directory structure.

ReSharper.FSharp/src/FSharp/FSharp.Fantomas.Protocol · high confidence

The F\# language service no longer uses the temporary fake parser and associated builder classes (FSharpFakeParser, FSharpFakeTreeBuilder, FSharpLanguageService, FSharpPsiBuilderTokenFactory). These stubs, which previously returned empty results or placeholder structures, have been deleted, indicating a shift toward a more complete or different parsing implementation for F\# code analysis.

ReSharper.FSharp/src/Psi.FSharp.LanguageService/src · high confidence

The \ReSharper.FSharp/src/Psi.FSharp/src/Gen\ directory has been removed, deleting all auto-generated F\# parser and PSI (Program Structure Interface) files. This includes the generated \FSharpParserGenerated\ class, \ErrorMessages\, \TokenBitsets\, \ElementType\, \FSharpFile\, and related visitor and test utilities. These files were previously generated by IntelliJ's parserGen tool and are no longer present in the codebase.

ReSharper.FSharp/src/Psi.FSharp/src/Gen · high confidence

The legacy F\# project properties implementation has been removed. This includes the deletion of the \FSharpProjectProperties\ class, its associated factory (\FSharpProjectPropertiesFactory\), the properties provider (\FSharpProjectFilePropertiesProvider\), and the assembly metadata file (\AssemblyInfo.cs\). Users relying on the previous F\# project model will need to use the new F\# backend support introduced in this change.

ReSharper.FSharp/src/Projects.FSharp · high confidence

The AssemblyInfo.cs files in the Psi.FSharp and Psi.FSharp.LanguageService projects have been deleted. This change removes the explicit assembly metadata (such as title, description, and version numbers) that was previously defined in these files, likely as part of migrating to the new fsproj/csproj format where such attributes are managed differently.

ReSharper.FSharp/src/Psi.FSharp.LanguageService/Properties, ReSharper.FSharp/src/Psi.FSharp/Properties · medium confidence

The legacy F\# PSI configuration file (FSharp.psi) and associated C\# classes (FSharpProjectFileLanguageService, FSharpPsiProperties) have been removed. This cleanup eliminates the old parser and PSI property definitions, reflecting a shift in how F\# project files and language services are handled within the IDE.

ReSharper.FSharp/src/Psi.FSharp/src · medium confidence

The legacy F\# PSI tree node classes, specifically FSharpCompositeElement and FSharpToken, have been removed from the codebase. This change eliminates the old implementations for handling F\# syntax tree nodes and tokens, likely as part of a broader refactoring or migration of the F\# backend support.

ReSharper.FSharp/src/Psi.FSharp/src/Impl · medium confidence

The F\# PSI tree implementation has been significantly restructured, introducing new base classes like FSharpCachedDeclarationBase and FSharpDeclarationBase to standardize how declarations and expressions are represented in the parse tree. This change affects how member declarations, patterns, and other language constructs are modeled, which may alter the behavior of IDE features that rely on the PSI tree, such as navigation, refactoring, and code analysis.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/Tree · medium confidence

The F\# plugin updated its internal resource strings, adding and refining messages for code analysis suggestions and quick-fixes. New or modified messages now cover simplifying lambda expressions, replacing redundant patterns, and handling mutable value constraints. These changes update the text users see when the IDE suggests code improvements or displays warnings.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Services/Resources · high confidence

The resource files for the F\# PSI features have been regenerated, introducing or updating the localized strings for the 'Reformat F\#' and 'Reformat code' actions, as well as the 'Processing redundancies in F\# code' action name. This ensures the UI displays the correct text for these code cleanup and reformatting features.

ReSharper.FSharp/src/FSharp/FSharp.Psi.Features/Resources · medium confidence

The F\# plugin now implements proper source accessibility for F\# type elements and improves script invalidation in the FcsCapturedInfoCache. This includes adding new classes for constructor, type, and type extension references, as well as utilities for parameter handling and access context. The caching mechanism for F\# captured info has been refined to better handle script invalidation and diagnostics, ensuring that changes to source files are correctly propagated and that unresolved symbols are reported appropriately.

ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Resolve · high confidence

Add tests for removing constructors in F\#; Add tests for the Remove Never Matching Rule quick fix; AddIgnoreFix: expanded test coverage for F\# quick fixes; Added C\# resolve test data for F\# interop; Added C\# resolve tests for F\# types and members; Added F\# assembly auto-open test data; Added F\# format specifier highlighting tests; Added F\# keyword completion tests for various code contexts; Added F\# lexer and parser tests for Rider; Added F\# parsing error test cases; Added F\# quick fix tests for auto property setters; Added F\# quick fix tests for converting instance members to static members; Added F\# quick fix tests for removing redundant parentheses; Added F\# quick fix tests for replacing equality expressions with assignments; Added F\# quick fix tests for underscore prefixing; Added F\# quick-fix tests for importing module members; Added F\# quick-fix tests for operator replacement; Added F\# resolve test cases for active patterns, qualified names, and indexers; Added F\# string escaping and interpolation test cases; Added F\# test data for TODO and NotImplementedException detection; Added F\# test suite for code completion, parameter info, and navigation; Added QuickDoc tests for F\# language features; Added and updated tests for F\# plugin components; Added baseline tests for F\# record field type signature quick fix; Added common test infrastructure for F\# plugin tests; Added completion selection tests for F\# custom operations; Added completion tests for F\# import suggestions in the same namespace; Added completion tests for F\# regex patterns; Added debugger expression evaluation tests for F\#; Added icon tests for F\# union case properties; Added lexer and parser tests for F\# string literals and directives; Added lexer test baselines for F\# syntax elements; Added name resolution test cases for F\# identifiers and modules; Added naming tests for F\# expression types; Added navigation test data for F\# anonymous records, dot-lambda shorthand, and wildcard patterns; Added parser tests for F\# string and interpolation edge cases; Added structure view test cases for F\# types; Added syntax highlighting tests for F\# preprocessor and XML documentation comments; Added test baselines for inferred type code vision; Added test cases for F\# completion in the same namespace; Added test cases for F\# extension attribute quick fixes; Added test cases for F\# extension member import quick fixes; Added test cases for F\# list pattern simplification; Added test cases for F\# override generation across various code representations; Added test cases for F\# partial application to lambda conversion; Added test cases for F\# quick fix 'Use Wild Self Id'; Added test cases for F\# quick fix: Replace with Abbreviated Type; Added test cases for F\# quick fix: remove subsequent expressions; Added test cases for F\# union case deconstruction quick fixes; Added test cases for RenameFileToMatchTypeName availability; Added test cases for removing redundant 'new' in F\#; Added test cases for the F\# 'Replace Let with Expression' quick fix; Added test cases for the F\# quick fix that adds missing \seq\ keywords; Added test cases for the F\# redundant qualifier quick fix; Added test cases for the Remove Unused Local Binding quick fix in F\#; Added test cases for the RemoveUnusedOpens quick fix; Added test data for C\# resolve tooltips; Added test data for F\# RemovePatternArgumentFix; Added test data for F\# ToAbstract quick fix; Added test data for F\# ToModuleNamespace intention; Added test data for F\# XML comment quick fixes; Added test data for F\# app expression analysis; Added test data for F\# inline removal quick fix; Added test data for F\# interpolated string candidate analysis; Added test data for F\# metadata reader; Added test data for F\# named access intention; Added test data for F\# namespace-to-module quick fix; Added test data for F\# pipe chain type hints; Added test data for F\# project model items container; Added test data for F\# quick fix converting tuples to array elements; Added test data for F\# quick fix import type popup; Added test data for F\# quick fix: add instance member self id; Added test data for F\# quick fix: specify type; Added test data for F\# quick fixes; Added test data for F\# record field signature quick fixes; Added test data for F\# recursion analysis; Added test data for F\# redundant attribute suffix detection and quick fix; Added test data for F\# regex detection; Added test data for F\# type hints in pattern matching and declarations; Added test data for Fantomas settings; Added test data for file system shim delegation; Added test data for inheritance gutter marks in F\#; Added test data for removing unnecessary upcasts; Added test data for the 'To Recursive Module' intention; Added test data for the F\# Simplify Lambda quick fix; Added test data for the Remove Yield quick fix; Added test data for the ToRecursiveFunction quick fix; Added test fixtures for F\# annotated entities; Added test fixtures for script file handling in multi-targeted and solution-level projects; Added test infrastructure for F\# intentions; Added test project build configuration; Added test project lockfile and subplatform configuration; Added tests for F\# 'Invert If' intention; Added tests for F\# AI summarizer; Added tests for F\# ToLiteral intention; Added tests for F\# code actions and intentions; Added tests for F\# code completion postfix templates; Added tests for F\# code completion scenarios; Added tests for F\# code editing actions; Added tests for F\# code formatting, structure, and metadata reading; Added tests for F\# code rearrangement of enum cases, record fields, union cases, and match clauses; Added tests for F\# comment line action; Added tests for F\# daemon highlighting and analysis; Added tests for F\# if/elif conversion intentions; Added tests for F\# inlay hints and type annotation intentions; Added tests for F\# inline and introduce variable refactoring; Added tests for F\# interface member generation; Added tests for F\# lambda replacement quick fixes; Added tests for F\# match lambda to parameter intention; Added tests for F\# nested record update syntax analysis and quick fixes; Added tests for F\# override generation; Added tests for F\# pattern matching intentions; Added tests for F\# quick fix to add missing match clauses; Added tests for F\# quick fix to add parentheses to typed expressions; Added tests for F\# quick fix to generate missing members; Added tests for F\# quick fix to replace interpolated strings with triple-quoted strings; Added tests for F\# quick fix to update mutability in signatures; Added tests for F\# quick fix to update parameter names in signatures; Added tests for F\# quick fix: Add parens to application; Added tests for F\# quick fix: change type; Added tests for F\# quick fix: specify base type; Added tests for F\# quick fixes; Added tests for F\# quick fixes and code cleanup; Added tests for F\# record field generation; Added tests for F\# record field mutability intentions; Added tests for F\# redundant 'as' pattern quick fix; Added tests for F\# redundant attribute parentheses; Added tests for F\# redundant qualifier analysis; Added tests for F\# refactoring features; Added tests for F\# symbol cache accessibility and module suffix handling; Added tests for F\# type annotation intentions; Added tests for F\# warning disable intentions; Added tests for color highlighting of F\# literals and properties; Added tests for debugger expression evaluation info provider; Added tests for negating conditions in if and while statements; Added tests for primitive type boxing and unboxing; Added tests for removing redundant attributes in F\#; Added tests for removing redundant backticks in F\# code; Added tests for removing unused named patterns in F\#; Added tests for removing unused self identifiers in F\# constructors and classes; Added tests for the 'Replace Use with Let' quick fix in F\#; Added tests for the 'Replace if with condition' analyzer; Added tests for the 'Replace lambda with inner expression' quick fix; Added tests for the 'To Recursive Let Bindings' intention; Added tests for the 'To Recursive Let Bindings' quick fix; Added tests for the 'To interpolated string' quick fix; Added tests for the 'replace with regular string' quick fix; Added tests for the F\# AddParensFix quick fix; Added tests for the F\# Remove Unexpected Arguments quick fix; Added tests for the F\# indexer dot removal quick fix; Added tests for the LetToUse intention; Added tests for the ToMultilineRecord code action; Enhanced Find Usages for F\# language constructs; Enhanced Find Usages for F\# language constructs; Expanded F\# code analysis and error highlighting tests; Expanded F\# error and warning test coverage; Expanded F\# lambda analyzer test coverage; Expanded test coverage for F\# deconstruction intentions; Expanded test coverage for F\# parameter info; Expanded test coverage for redundant parentheses detection in F\# type usage; F\# argument highlighting tests; F\# quick fix for replacing return types; F\# test suite migrated to JUnit 5 and the new test framework; Improved F\# attribute and member resolution in the assembly reader; Improved F\# import type quick fix for accessibility, qualifiers, and nested modules; Improved detection of redundant parentheses in F\# patterns; Introduce Var quick fix: expanded test coverage for sequence and module-level expressions; Test coverage for F\# match completeness quick-fix; Tests added for F\# quick fix to make values mutable; Updated F\# QuickDoc test data for new and existing language constructs; Updated F\# code completion test baselines; Updated F\# code completion test data for new and existing scenarios; Updated F\# completion test baselines for pattern matching and record syntax; Updated F\# navigation test baselines for base types, members, and object expressions; Updated F\# navigation test baselines for declaration resolution; Updated F\# navigation test baselines for inheritors; Updated F\# parser test baselines for attributes, bindings, and directives; Updated F\# signature parsing test baselines; Updated F\# test assembly sources for unit testing; Updated availability tests for F\# type annotation intentions; Updated parameter info auto-popup test cases for F\#; Updated test baselines for F\# identifier highlighting; Updated test data configuration and gitignore for F\# tests; Updated test data for F\# lambda syntax quick fix; Updated test data for redundant parentheses detection; Updated test data for the 'Replace with \_' quick fix.

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 56.

• Code Health 54
• Architecture 60
• Maturity 53
• Readiness 63
• Security 68

• 300 commits — 235 feature/other, 65 fixes

• ReSharper.FSharp/src — 103 commits
• rider-fsharp/src — 89 commits
• ReSharper.FSharp/test — 50 commits
• rider-fsharp/build.gradle.kts — 24 commits
• rider-fsharp/parserTest — 9 commits
• rider-fsharp/injections — 8 commits
• rider-fsharp/gradle.properties — 7 commits
• (root) — 4 commits
• rider-fsharp/gradle — 2 commits
• (repo) — 1 commit
• .github/workflows — 1 commit
• ReSharper.FSharp/Directory.Build.props — 1 commit
• rider-fsharp/protocol — 1 commit

• fix: Code structure/Patterns: fix NRE (#1159)
• fix: F# Scripts: fix fcsCapturedInfo caching (#1197)
• fix: FcsCapturedInfoCache: fix write assert for 'InvalidateScript'
• fix: FcsCapturedInfoCaches: fix invalidation
• fix: Fix RSCPP-37367 CLion rename refactoring rejects valid C identifiers that are C++ keywords
• fix: Fix RSRP-502908 Completion (intellisense) Fluent style icons
• fix: IJI-2756 Fixed origin rev id after monorepo force push (main)
• fix: IJPL-222430 rdct, ij-light, rider: One More Time: move fus to the embedded location and fix rebase issues
• fix: IJPL-224042 IJ-MR-184958 IJ-MR-184993 IJ-MR-179029 IJ-MR-184126 IJ-MR-181153 IJ-MR-146078 IJ-MR-175479 IJ-MR-186058 fix direct use of intellij.libraries.kotlinTest
• fix: IJPL-224042 fix f* gradle
• fix: IJPL-225367 [platform]: Fix the order of CodeFoldingOptionsProvider
• fix: IJPL-251390 fix modules visibility after all deps explicit
• fix: Intentions/Disable warning: fix warning id syntax for F# 8 (#1185)
• fix: NP-2141 Asserts: fix broken defines condition in the monorepo
• fix: Parser/WarningDirective: fix for AdvanceLexer (#1076)
• fix: Psi/Record: fix for private constructors (#1009)
• fix: Quick fixes/change type: support union and exception fields
• fix: RIDER-102738 Fix FcsModuleReaderTest
• fix: RIDER-124491 Completion/import/extensions: fix applicable type, accessbility, and imported scope checks
• fix: RIDER-128433 Rider .NET Intentions Previews: fix CC tests sorting order in relevance presenter
• …and 280 more

• 3 containers · 1 bounded contexts · 0 dependency edges (baseline)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.