release-notes.md

Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information.

About the release notes

For the most recent release notes see: /docs/release-notes

This document contains historical release notes information. They are preserved in their original form.

• Current Release notes
• Visual Studio 2017-2019 release notes
• FSharp.Compiler.Service release notes (version 37 and lower)
• Older release notes (pre-F# 4.0)

Current release notes

These release notes track our current efforts to document changes to the F# project over time. They are split into the language, core library, compiler/tools, and compiler service.

FSharp Compiler Service (main)

• In FSharpParsingOptions, rename ConditionalCompilationDefines --> ConditionalDefines
• Some syntax tree nodes have changed, e.g. introduction of SyntaxTree trivia
• Resolved expressions (FSharpExpr) now reveal debug points, you must match them explicitly using DebugPoint(dp, expr)
• Some node types in FSharpExpr (e.g. Let, While, TryFinally, TryWith) reveal additional debug points
• In FSharpExpr, FastIntegerForLoop has been renamed to IntegerForLoop
• SynModuleDecl.DoExpr --> SynModuleDecl.Expr because it was not corresponding to a 'do expr' declaration. A 'do expr' declaration in a module will correspond to a SynModuleDecl.Expr enclosing a SynExpr.Do This constructor also loses the debug point as it was always None. The debug point is always implicit for this construct.
• In FCS API, FSharpParsingOptions, CompilingFsLib --> CompilingFSharpCore
• In FCS API, FSharpParsingOptions, ErrorSeverityOptions --> DiagnosticOptions
• SynIdent was introduced in the Untyped Syntax Tree. This represent an Ident with potential additional information, stored as IdentTrivia).
• LongIdentWithDots was renamed to SynLongIdent and also could contain IdentTrivia. Due to this change, infix operators are stored as SynExpr.LongIdent instead of SynExpr.Ident. a + b is parsed as SynLongIdent([op_Addition], [], [Some (OriginalNotation "+")]).
• SynMeasure was extended with SynMeasure.Paren case.
• Dynamic expressions (like x?y) are now represented as SynExpr.Dynamic in the Untyped Syntax Tree.
• Members with get and/or set are now represented as SynMemberDefn.GetSetMember in the Untyped Syntax Tree.
• DoesIdentifierNeedBackticks is removed, it should always be sufficient to call NormalizeIdentifierBackticks or else call something in PrettyNaming
• AddBackticksToIdentifierIfNeeded is removed, it should always be sufficient to call NormalizeIdentifierBackticks
• DeclarationListItem.Name --> DeclarationListItem.NameInList

F# 6.0 / Visual Studio 17.0

FSharp.Core 6.0.0

• Update F# Tooling, Language and F# Core version numbers

FSharp.Core 5.0.2

• Fix #11143 - FSharp.Core 5.0.1 should not have FSharp.Core.xml in contentFiles #11160

FSharp.Core 5.0.1

• Performance improvement to core collections Map by Victor Baybekov

FSharp tools 12.0.0

• Update F# Tooling, Language and F# Core version numbers

FSharp tools 11.0.1

• Significant improvements to the performance of code making heavy use of closures at runtime
• Warnings for mismatched parameter names between signature and implementation files
• Warnings for incorrect XML documentation files are turned on by default
• Big performance gains in tools for codebases with F# signature files
• Improved responsiveness for most IDE features
• Signature Help for F# function calls
• .NET 5 scripting for Visual Studio
• Add ConvertToAnonymousRecord quick fix #10493
• Add UseMutationWhenValueIsMutable code fix #10488
• Add MakeDeclarationMutable code fix #10480
• Add ChangeToUpcast code fix #10463
• Add AddMissingEqualsToTypeDefinition code fixer #10470
• Tag items in tooltips consistently with respect to document classification. #9563
• Add ConvertToSingleEqualsEqualityExpression code fix #10462
• Turn XML doc and Sig<->Impl mismatch warnings on by default #10457
• Add ChangeRefCellDerefToNotExpression code fixer #10469
• Add WrapExpressionInParentheses code fix #10460
• Add ChangePrefixNegationToInfixSubtraction code fixeroo #10471
• Fix generic overloads with nullable #10582
• Resolve issue with implicit yields requiring Zero #10556, by Ryan Coy
• Fix issue10550 FSI accessing System.Configuration. #10572
• Add field names to ILNativeType.Custom. #10567, by Scott Hutchinson
• Add field names to the ILExceptionClause.FilterCatch constructor. #10559, by Scott Hutchinson
• Fix completion with backticks, underscores, numbers #10500, by zanaptak
• Emitting IsReadOnly/In attributes on abstract properties #10542
• Disable partial type checking when getting full results for a file #10448
• Fix unused open type declaration detection #10510, by André Slupik

FSharp Compiler Service 41.0.0

• Update F# Tooling, Language and F# Core version numbers

FSharp Compiler Service 40.0.0

This is a second big update to FCS. There are significant trimmings and renamings of the API and gets it close to a more permanent form:

The primary namespaces are now:

FSharp.Compiler.IO                // FileSystem
FSharp.Compiler.CodeAnalysis      // FSharpChecker, FSharpCheckFileResults, FSharpCheckProjectResults and friends
FSharp.Compiler.Diagnostics       // FSharpDiagnostic and friends
FSharp.Compiler.EditorServices    // Misc functionality for editors, e.g. interface stub generation
FSharp.Compiler.Interactive.Shell // F# Interactive
FSharp.Compiler.Symbols           // FSharpEntity etc
FSharp.Compiler.Syntax            // SyntaxTree, XmlDoc, PrettyNaming
FSharp.Compiler.Text              // ISourceFile, Range, TaggedText and other things
FSharp.Compiler.Tokenization      // FSharpLineTokenizer etc.

Changes in FSharp.Compiler.Diagnostics

• ErrorHelpers --> DiagnosticHelpers

• ErrorResolutionHints.getSuggestedNames --> ErrorResolutionHints.GetSuggestedNames

Changes in FSharp.Compiler.SourceCodeServices

• Everything is moved to one of the other namespaces

• The FSharp prefix is used for things in FSharp.Compiler.Symbols but not FSharp.Compiler.EditorServices

• AssemblyContentProvider --> AssemblyContent in EditorServices

• AstVisitorBase --> moved to SyntaxVisitorBase in FSharp.Compiler.Syntax

• AstVisitorBase.* --> SyntaxVisitorBase.* and methods now all take path parameters consistently

• AstTraversal.Traverse --> SyntaxTraversal.Traverse

• BasicPatterns --> FSharpExprPatterns in FSharp.Compiler.Symbols

• DebuggerEnvironment.* merged into CompilerEnvironment in FSharp.Compiler

• ExternalType --> FindDeclExternalType in EditorServices

• FSharpChecker.ParseFileNoCache --> removed in favour of optional cache=false argument on FSharpChecker.ParseFile

• FSharpChecker.BeforeBackgroundFileCheck event now takes FSharpProjectOptions arg

• FSharpChecker.FileChecked event now takes FSharpProjectOptions arg

• FSharpChecker.FileParsed event now takes FSharpProjectOptions arg

• FSharpChecker.ProjectChecked event now takes FSharpProjectOptions arg

• FSharpCheckFileResults.Errors --> FSharpCheckFileResults.Diagnostics

• FSharpCheckProjectResults.Errors --> FSharpCheckProjectResults.Diagnostics

• FSharpDeclarationListInfo --> DeclarationListInfo in EditorServices

• FSharpEnclosingEntityKind --> NavigationEntityKind in EditorServices

• FSharpExternalSymbol --> FindDeclExternalSymbol in EditorServices

• FSharpFileUtilities.* merged into CompilerEnvironment in FSharp.Compiler

• FSharpFindDeclResult --> FindDeclResult in EditorServices

• FSharpLexer.Lex --> FSharpLexer.Tokenize in FSharp.Compiler.Tokenization

• FSharpMethodGroup --> MethodGroup in EditorServices

• FSharpMethodGroupItem --> MethodGroupItem in EditorServices

• FSharpMethodGroupItemParameter --> MethodGroupItemParameter in EditorServices

• FSharpMethodGroupItemParameter.StructuredDisplay ---> MethodGroupItemParameter.Display

• FSharpMethodGroupItemParameter.StructuredReturnTypeText ---> MethodGroupItemParameter.ReturnTypeText

• FSharpNavigationDeclarationItem --> NavigationItem in EditorServices

• FSharpNavigationTopLevelDeclaration --> NavigationTopLevelDeclaration in EditorServices

• FSharpNavigationItems --> NavigationItems in EditorServices

• FSharpNavigation --> Navigation in EditorServices

• FSharpNavigationDeclarationItemKind --> NavigationItemKind in EditorServices

• FSharpNoteworthyParamInfoLocations --> ParameterLocations

• FSharpProjectOptions.ExtraProjectInfo is removed

• FSharpSemanticClassificationItem --> SemanticClassificationItem in EditorServices

• FSharpSemanticClassificationView --> SemanticClassificationView in EditorServices

• FSharpStructuredToolTipText --> ToolTipText in EditorServices

• FSharpStructuredToolTipElementData --> ToolTipElementData in EditorServices

• FSharpStructuredToolTipElement --> ToolTipElement in EditorServices

• FSharpSymbol.Accessibility is now non-optional. Will return "public" in cases it previously returned "None"

• FSharpSymbol.XmlDoc now returns FSharpXmlDoc with cases for internal and external XML doc. Use match symbol.XmlDoc with FSharpXmlDoc.FromText doc -> doc.UnprocessedLines to get unprocessed XML lines

• FSharpSymbol.ElaboratedXmlDoc now removed. Use match symbol.XmlDoc with FSharpXmlDoc.FromText doc -> doc.GetElaboratedLine()

• FSharpToolTipText --> ToolTipText in EditorServices

• FSharpToolTipElementData --> ToolTipElementData in EditorServices

• FSharpToolTipElement --> ToolTipElement in EditorServices

• FSharpType.FormatLayout now returns TaggedText[]

• FSharpType.FormatLayout now returns TaggedText[]

• FSharpUnresolvedSymbol --> UnresolvedSymbol in EditorServices

• InterfaceStubGenerator.* are all capitalized

• Idents --> ShortIdents in EditorServices

• LongIdent abbreviation removed and replaced by string

• NavigateTo.NavigableItemKind --> now directly in EditorServices

• NavigateTo.ContainerType --> NavigableContainerType now directly in EditorServices

• NavigateTo.NavigableItem --> NavigableItem now directly in EditorServices

• NavigateTo.getNavigableItems --> NavigateTo.GetNavigableItems in EditorServices

• ParamTypeSymbol --> FindDeclExternalParam in EditorServices

• ParsedInput.tryFindInsertionContext --> ParsedInput.TryFindInsertionContext

• ParsedInput.findNearestPointToInsertOpenDeclaration --> ParsedInput.FindNearestPointToInsertOpenDeclaration

• ParsedInput.getLongIdentAt --> ParsedInput.GetLongIdentAt

• ParsedInput.adjustInsertionPoint --> ParsedInput.AdjustInsertionPoint

• Symbol --> FSharpSymbolPatterns in FSharp.Compiler.Symbols and marked experimental

• Symbol.isAttribute --> now attrib.IsAttribute<'T>()

• Symbol.getAbbreviatedType --> now symbol.StripAbbreviations()

• Symbol.hasAttribute --> now symbol.HasAttribute<'T>()

• Symbol.tryGetAttribute --> now symbol.TryGetAttribute<'T>()

• TraverseStep --> SyntaxNode in FSharp.Compiler.Syntax

• ToolTips now only return the structured (TaggedText) tooltips. You can iterate to get the text tooltips

Changes in FSharp.Compiler.Text

• Pos --> Position

Changes in FSharp.Compiler.TextLayout

• Everything moves to FSharp.Compiler.Text

• LayoutTag --> TextTag

• Layout is now internal and replaced by TaggedText[]

• LayoutOps is now internal

Changes in FSharp.Compiler.SyntaxTree

• Everything moves to namespace FSharp.Compiler.Syntax

• DebugPointAtBinding is now RequireQualifiedAccess

• NoDebugPointAtStickyBinding --> DebugPointAtBinding.NoneAtSticky

• Clause --> SynMatchClause

• NormalBinding -> SynBindingKind.Normal

• Binding --> SynBinding

• Field --> SynField

• UnionCase --> SynUnionCase

• UnionCaseFullType --> SynUnionCaseKind.FullType

• UnionCaseFields --> SynUnionCaseKind.Fields

• MemberKind --> SynMemberKind

• MemberFlags --> SynMemberFlags

• TyconUnspecified --> SynTypeDefnKind.Unspecified

• TyconClass --> SynTypeDefnKind.Class

• TyconInterface --> SynTypeDefnKind.Interface

• TyconStruct --> SynTypeDefnKind.Struct

• TyconHiddenRepr --> SynTypeDefnKind.Opaque

• TyconUnion --> SynTypeDefnKind.Union

• TyconDelegate --> SynTypeDefnKind.Delegate

• ComponentInfo --> SynComponentInfo

• TyconAugmentation --> SynTypeDefnKind.Augmentation

• TypeDefnSig --> SynTypeDefnSig

• HeadTypeStaticReq --> TyparStaticReq.HeadType

• NoStaticReq --> TyparStaticReq.None

• SynTypeConstraint is now RequiresQualifiedAccess

• ValSpfn --> SynValSpfn

• TyparDecl --> SynTyparDecl

• Typar --> SynTypar

• SynSimplePatAlternativeIdInfo is now RequiresQualifiedAccess

• InterfaceImpl --> SynInterfaceImpl

• SynBindingKind is now RequiresQualifiedAccess

• DoBinding --> SynBindingKind.Do

• StandaloneExpression --> SynBindingKind.StandaloneExpression

• SynModuleOrNamespaceKind is now RequiresQualifiedAccess

• IDefns --> ParsedScriptInteraction.Definitions

• IHash --> ParsedScriptInteraction.HashDirective

Other changes

• LegacyReferenceResolver now marked obsolete

FSharp Compiler Service 39.0.0

This is a big update to FCS. There are significant trimmings and renamings of the API as a first step towards getting it under control with aims to eventually have a stable, sane public API surface area.

Renamings:

-type FSharp.Compiler.AbstractIL.Internal.Library.IFileSystem
+type FSharp.Compiler.SourceCodeServices.IFileSystem

-module FSharp.Compiler.AbstractIL.Internal.Library.Shim
+FSharp.Compiler.SourceCodeServices.FileSystemAutoOpens

-type FSharp.Compiler.AbstractIL.Layout
+type FSharp.Compiler.TextLayout.Layout

-type FSharp.Compiler.AbstractIL.Internal.TaggedText
+type FSharp.Compiler.TextLayout.TaggedText

-type FSharp.Compiler.Layout.layout
+type FSharp.Compiler.TextLayout.layout

-type FSharp.Compiler.Layout.Layout
+FSharp.Compiler.TextLayout.Layout

-module FSharp.Compiler.Layout
+module FSharp.Compiler.TextLayout.LayoutRender

-module FSharp.Compiler.LayoutOps
+module FSharp.Compiler.TextLayout.Layout

-module FSharp.Compiler.Layout.TaggedText
+module FSharp.Compiler.TextLayout.TaggedText

-module FSharp.Compiler.Layout.TaggedTextOps
+FSharp.Compiler.TextLayout.TaggedText

-module FSharp.Compiler.Layout.TaggedTextOps.Literals
+FSharp.Compiler.TextLayout.TaggedText

-type FSharp.Compiler.Range.range
+FSharp.Compiler.Text.Range

-type FSharp.Compiler.Range.pos
+FSharp.Compiler.Text.Pos

-module FSharp.Compiler.Range.Range
+module FSharp.Compiler.Text.Pos
+module FSharp.Compiler.Text.Range

-module FSharp.Compiler.QuickParse
+module FSharp.Compiler.SourceCodeServices.QuickParse

-module FSharp.Compiler.PrettyNaming
+FSharp.Compiler.SourceCodeServices.PrettyNaming

-val FSharpKeywords.PrettyNaming.KeywordNames
+FSharp.Compiler.SourceCodeServices.FSharpKeywords.KeywordNames

-val FSharpKeywords.PrettyNaming.QuoteIdentifierIfNeeded
+FSharp.Compiler.SourceCodeServices.FSharpKeywords.QuoteIdentifierIfNeeded

-val FSharpKeywords.PrettyNaming.FormatAndOtherOverloadsString
+FSharp.Compiler.SourceCodeServices.FSharpKeywords.FormatAndOtherOverloadsString

Renamings in FSharp.Compiler.SourceCodeServices:

-Lexer.*
+FSharp.Compiler.SourceCodeServices.*

-FSharpSyntaxToken*
+FSharpToken*

-FSharpErrorInfo
+FSharpDiagnostic

-FSharpErrorSeverity
+FSharpDiagnosticSeverity

-ExternalSymbol
+FSharpExternalSymbol

-UnresolvedSymbol
+FSharpUnresolvedSymbol

-CompletionKind
+FSharpCompletionKind

-module Keywords 
+module FSharpKeywords

• Extension methods in ServiceAssemblyContent.fsi are now intrinsic methods on the symbol types themselves.
• SemanticClassificationType is now an enum instead of a discriminated union.
• GetBackgroundSemanticClassificationForFile now returns Async<SemanticClassificationView option> instead of Async<struct(range * SemanticClassificationType) []>. The SemanticClassificationView provides a read-only view over the semantic classification contents via the ForEach (FSharpSemanticClassificationItem -> unit) -> unit function.

The following namespaces have been made internal

• FSharp.Compiler.AbstractIL.*, aside from a small hook for JetBrains Rider
• FSharp.Compiler.ErrorLogger.*

New functions in the SourceCodeServices API:

• FSharpDiagnostic.NewlineifyErrorString
• FSharpDiagnostic.NormalizeErrorString

F# 5 / Visual Studio 16.8 / .NET 5

This release covers three important milestones: F# 5, Visual Studio 16.8, and .NET 5.

FSharpLanguage 5.0.0

• Package references in scripts via #r "nuget:..."
• String interpolation
• Support for nameof and the nameof pattern by Microsoft and Loïc Denuzière
• open type declarations
• Applicative computation expressions via let! ... and!
• Overloads for custom operations in computation expressions (in preview), by Ryan Riley and Diego Esmerio
• Interfaces can now be implemented at different generic instantiations
• Default interface member consumption
• Better interop with nullable value types

FSharp Core 5.0.0

• Consistent behavior for empty/nonexistent slices for lists, strings, arrays, 2D arrays, 3D arrays, and 4D arrays
• Support for fixed-index slices in 3D and 4D arrays
• Support for negative indexes (in preview)
• Reverted a change where the %A and %O and ToString/string result of a union with RequireQualifiedAccess gave the fully-qualified union case name in response to user feedback
• Significantly improved XML documentation for all APIs
• Optimized reflection for F# types by kerams

FSharp Tools 11.0.0

• Improved batch compilation performance (up to 30% faster depending on the project type)
• Support for editing #r "nuget:..." scripts in Visual Studio
• Various fixes for F# script editing performance, especially for scripts with significant dependencies getting loaded
• Support for compiling against .NET Core on Windows when no STAThread is available
• Support for validating signatures against XML doc comments when compiling via /warnon:3390
• Fixed a bug where FSharp.Core XML doc contents were not displayed in F# scripts in Visual Studio
• Support for strong name signing against F# projects when compiling using the .NET SDK
• Fixed a bug where manually referencing Akkling.Cluster.Sharding.0.9.3 in FSI would not work
• Bring back the custom colorization options that were missed in the 16.7 update
• Support coloring disposable values independently from disposable types
• Fix a bug where emitting an inref<_> could cause a value to no longer be consumable by C#
• Support displaying Some x when debugging F# options in Visual Studio, by Friedrich von Never
• Fix a bug where compiling large anonymous records could fail in release mode
• Support for considering struct tuples and struct anonymous records as subtypes of System.ValueTuple
• Fix several internal errors in the compiler when compiling various niche scenarios
• Various performance enhancements when editing large files by Microsoft and Daniel Svensson
• Optimized output for the string function, by Abel Braaksma
• Various fixes for some display regressions for Find all References in Visual Studio
• Fix duplicate symbol output when renaming constructs in a project with multiple TFMs
• Support for Int64.MinValue as a nativeint literal, by Abel Braaksma
• Prevent assignment to const fields, by Chet Husk
• Compiler message improvements (especially for overload resolution) by Gauthier Segay, Vladimir Shchur, and Microsoft

FSharp Compiler Service 38.0.2

• Add FSharp.DependencyManager.Nuget as a project reference and ensure it is in the package, allowing other editors to consume #r "nuget:..." references at design-time #10784

FSharp Compiler Service 38.0.1

• Add check for system assemblies completion #10575
• Fix net sdk references discovery #10569
• Fix FSC nuget package dependencies #10588

FSharp Compiler Service 38.0.0

The most notable change for FSharp.Compiler.Service is that it is now built and deployed as a part of the dotnet/fsharp codebase. Builds are produced nightly, matching exactly the nightly builds of the F# compiler, FSharp.Core, and F# tools.

• Support for Witness information #9510 in FSharpExpr and FSharpMemberOrFunctionOrValue
• Support for Jupyter Notebooks and VSCode notebooks via FSharp.Compiler.Private.Scripting and .NET Interactive
• Improvements to the F# syntax tree representation by Eugene Auduchinok
• Support for const in keyword completion info by Alex Berezhnykh
• Support for passing in a PrimaryAssembly for AST compilation routines by Eirik Tsarpalis
• Support for ToString in FSharp.Compiler.SourceCodeServices.StringText by Asti
• Fix an issue with equality comparisons for StringText by Asti

Significant changes for consumers:

• Several APIs no longer require the Reactor thread
• GetAllUsesOfAllSymbolsInFile now returns seq<FSharpSymbol> instead of FSharpSymbol[]
• All four Get*UsesOfAllSymbolsIn* APIs are no longer asynchronous
• StructuredDescriptionTextAsync and DescriptionTextAsync are now deprecated, please use StructuredDescriptionText and DescriptionText instead
• The hasTextChangedSinceLastTypecheck optional argument has been removed (it has been unused in Visual Studio since VS 2017)
• The textSnapshotInfo optional argument is removed as it only made sense in tandem with hasTextChangedSinceLastTypecheck
• userOpName is removed from all APIs that are no longer asynchronous

Visual Studio 2017-2019 Update 16.7 release notes

These release notes contain release notes for all F# product release delivered alongside Visual Studio since Visual Studio 2017 and up until Visual Studio 2019 update 16.7.

Visual Studio 16.7

This release is focused on closing out F# 5 feature development and making Visual Studio tooling improvements.

F# language

The following features were added to F# 5 preview:

• String interpolation
• Complete nameof design implementation
• nameof support for patterns
• open type declarations
• Overloads of custom keywords in computation expressions
• Interfaces can be implemented at different generic instantiation

F# compiler and tools

• Various bug fixes
• Updated semantic classification to better distinguish various F# constructs from one another
• Improvements to performance of various array-based operations in FSharp.Core by Abel Braaksma
• Various improvements to the F# compiler service by Eugene Auduchinok
• Improvements to SourceLink support by Chet Husk
• Support for Map.change by Fraser Waters

Visual Studio 16.6

This release is focused on more F# 5 preview features and Visual Studio tooling improvements.

F# language

The following features were added to F# 5 preview:

• Support for interop with Default Interface Methods
• Improvements for #r "nuget" - allow packages with native dependencies
• Improvements for #r "nuget" - allow packages like FParsec that require .dlls to be referenced in a particular order
• Improved interop with Nullable Value Types

F# compiler and tools

• Various bug fixes
• Significant improvements to memory usage for symbol-based operations such as Find All References and Rename, especially for large codebases
• 15% or higher reduction in compile times (as measured by compiling FSharpPlus.dll)
• Performance improvements for design-time builds by Saul Rennison
• Improved stack traces in F# async and other computations, thanks to Nino Floris
• All new F# project types now use the .NET SDK
• Descriptions in completion lists for tooltips
• Improved UI for completion for unimported types
• Bug fix for adding a needed open declaration when at the top of a file (such as a script)
• Various improvements to error recovery and data shown in tooltips have been contributed by Eugene Auduchinok and Matt Constable.
• Various compiler performance improvements by Steffen Forkmann
• Improvements to F# CodeLenses by Victor Peter Rouven Muller
• Better emitted IL for uint64 literals by Teo Tsirpanis

Visual Studio 16.5

The primary focus of this release has been improving the performance and scalability of large F# codebases in Visual Studio. This work was influenced by working directly with customers who have very large codebases. The performance work is still ongoing, but if you have a medium-to-large sized codebase, you should see reduced memory usage.

Beyond performance enhancements, this release includes a variety of other fixes, many of which were contributed by our wonderful F# OSS community.

F# language

Several F# preview language features have been merged. You can try them out by setting your LangVersion to preview in your project file.

• F# RFC FS-1076 - From the end slicing and indexing for collections has been completed for F# preview
• F# RFC FS-1077 - Tolerant Slicing has been completed for F# preview
• F# RFC FS-1077 - Slicing for 3D/4D arrays with fixed index has been completed for F# preview
• F# RFC FS-1080 - Float32 without dot has been completed for F# preview, contributed by Grzegorz Dziadkiewicz

F# compiler

• Support for --standalone has been added for .NET Core
• Various improvements to error recovery have been contributed by Eugene Auduchinok
• Support for generating an AssemblyInfo from a project file has been added
• Better error reporting for mismatched Anonymous Records was contributed by Isaac Abraham
• A bug where use of type abbreviations could bypass byref analysis in the compiler has been resolved
• It is now possible to specify the [<Literal>] attribute in F# signature files
• A bug where the LangVersion flag was culture-dependent has been resolved
• A bug where large types and expressions defined in source would lead to a stack overflow has been resolved
• A bug where arbitrary, nonsense attributes could be defined on F# type extensions was resolved
• A bug where exhaustive matches on SByte and Byte literal values emitted a warning was resolved
• A bug where invalid type abbreviations with byrefs and byref-like values could be defined was resolved
• A bug where invalid binary and octal literals would be accepted by the compiler was resolved, contributed by Grzegorz Dziadkiewicz
• A bug where P/Invoke to "kernel32.dll" was getting called in a FreeBSD source build of .NET Core has been resolved by Adeel Mujahid
• Various smaller performance improvements have been added by Eugene Auduchinok and Steffen Formann

F# core library

• A bug where calling string or .ToString on ValueNone would throw an exception has been resolved
• A bug where calling Async.Sleep within a sequentially processed set of async expressions wouldn't process sequentially has been resolved, contributed by Fraser Waters
• An issue in Async.Choice that could lead to memory leaks has been resolved, contributed by Fraser Waters

F# tools for Visual Studio

• A bug where the Product Version in the About Visual Studio window mistakenly displayed F# 4.6 has been resolved
• A bug where the fsi type in F# scripts was incorrectly treated as not defined has been resolved

F# open source development experience

• The FSharp.Compiler.Service build in the F# repository has been moved to use the .NET SDK, contributed by Chet Husk

Visual Studio 16.3

This release includes support for F# 4.7, the newest version of the F# language!

Much of F# 4.7 was dedicated to underlying infrastructural changes that allow us to deliver preview of F# language functionality more effectively. That said, there are still some nice new features delivered as well.

F# language and core library

We added support for F# 4.7, a minor language release that comes with compiler infrastructure to enable preview features so that we can get feedback on feature designs earlier in the development process.

The full F# 4.7 feature set is:

• Support for the LangVersion flag, which allows for configuring the F# language version used by the compiler to be F# 4.6 or higher
• Support for implicit yields in array, list, and sequence expressions
• Indentation requirement relaxations for static members and constructors
• Relaxing the need for a double-underscore (__) in member declarations and for loops, contributed by Gustavo Leon
• FSharp.Core now targets netstandard2.0 instead of netstandard1.6, following the deprecation of support for .NET Core 1.x
• FSharp.Core on .NET Core now supports FSharpFunc.FromConverter, FSharpFunc.ToConverter, and FuncConvert.ToFSharpFunc
• FSharp.Core now supports Async.Sequential and an optional maxDegreeOfParallelism parameter for Async.Parallel, contributed by Fraser Waters

In addition to the F# 4.7 feature set, this release includes support for the following preview F# language features:

• Support for nameof expressions
• Support for opening of static classes

You can enable this by setting <LangVersion>preview</LangVersion> in your project file.

This release also contains the following bug fixes and improvements to the F# compiler:

• A longstanding issue where the F# compiler could stack overflow with massive records, structs, or other types has been resolved (#7070)
• An issue where specifying invalid inline IL could crash Visual Studio has been resolved (#7164
• Resolution of an issue where copying of a struct would not occur if it was defined in C# and mutated in a member call (#7406)
• A crypto hash of the portable PDB content created by the compiler is not included in the PE debug directory, with a configurable hash set to SHA-256 by default (#4259, #1223)
• A bug where LeafExpressionConverter ignored ValueType and assumed System.Tuple has been fixed (#6515) by Kevin Malenfant
• A bug where List.transpose discarded data instead of throwing an exception has been resolved (#6908) by Patrick McDonald
• A bug where List.map3 gave a misleading error when used on lists of different lengths has been resolved (#6897) by reacheight

F# tools

This release also includes a few improvements to the F# tools for Visual Studio:

• Records are formatted more to look more like canonical declarations and values in tooltips and F# interactive (#7163)
• Properties in tooltips now specify whether or not that are get-only, set-only, or get and set (#7007)
• An issue where Go to Definition and other features could not always work across projects when files use forward slashes (#4446, #5521, #4016) has been fixed, with help from chadunit
• Issues with anonymous records and debugging have been resolved (#6728, #6512)
• A bug where empty hash directives in source could make source text coloring seem random has been resolved (#6400, #7000)

Visual Studio 16.1

This is a relatively minor release for the F# language and tools, but it's not without some goodies! As with the VS 16.0 update, this release also focused on performance of editor tooling.

F# compiler and F# interactive

• Added P/Invoke support to F# interactive on .NET Core (#6544)
• Added a compiler optimization for Span<'T> when used in a for loop (#6195)
• Added an optimization to avoid an extraneous Some allocations for F# options in various scenarios (#6532)
• Changed the execution order of expressions used in the instantiation of Anonymous Records to be top-to-bottom, rather than alphabetical, to match the current experience with normal Records (#6487)
• A bug where very large literal expressions or very large struct declarations could cause the compiler to stack overflow on build has been resolved (#6258)
• A bug where breakpoints would no longer trigger when debugging a function with an Anonymous Records has been fixed (#6512)
• A bug where Anonymous Records passed to constructs expecting an obj parameter caused a compiler crash has been fixed (#6434)
• A bug where for var expr1 to expr2 do ... loops could result in bizarrely valid (and discarded) syntax has been fixed (#6586)
• A bug where Anonymous Records could not be used properly with events has been fixed (#6572)
• A longstanding bug where extremely large generated parsers in FsLexYacc (over 100 million lines) has been resolved (#5967
• A longstanding issue in the Type Provider plugin component of the compiler that could leave the door open for a memory leak caused by a type provider has been resolved (#6409)
• Support for --pathmap was added to the F# compiler by Saul Rennison, which resolves an issue where the resulting executable from a compilation would include absolute paths to source files in the embedded F# signature file resource (#5213)
• An optimization to the F# AST that improves its consumption via other tools and environments (e.g., Fable) has been added by ncave (#6333)
• An optimization around traversing information when resolving members has been added by Steffen Forkmann (#4457)
• An improvement to error messages such that when a type implementation is missing necessary overrides a list of those missing overrides is reported has been added by Gauthier Segay (#4982)

F# tools

• The Target Framework dropdown for F# projects in the .NET SDK will now include values for all available .NET Core, .NET Standard, and .NET Framework values to ease migrating to .NET Core from .NET Framework on the .NET SDK
• A bug where renaming generic type parameters produces double backtick-escaped names has been fixed (#5389)
• A longstanding problem where Type Providers were redundantly reinstantiated, causing massive allocations over time, has been resolved (#5929)
• A longstanding issue where reading IL needlessly allocated 20MB over a short period of time was been resolved (#6403)
• A bug where the method GetToolTipText in the F# compiler service could show the same XML signature for several member overloads has been resolved by Vasily Kirichenko (#6244)

F# open source infrastructure

Finally, we improved the contribution experience by doing the following:

• Completed our build from source process so that the F# compiler and core library can be built with the .NET Core source build repository
• Removed our dependency on netstandard1.6 so that the entire codebase uniformly targets netstandard2.0 and net472
• Added a .vsconfig file to the root of the repository so that contributors using Visual Studio don't have to know everything that needs installing up front
• Rewrote our project's README to remove potentially confusing information, include a quickstart for getting started with contributing, and attempting to be more inclusive in our messaging about the kinds of changes we'd love to take

Visual Studio 16.0

F# improvements in Visual Studio 2019 are in three major areas:

• F# 4.6
• Major performance improvements for medium and larger solutions
• Lots of open source work by our excellent open source community

F# 4.6

This release contains the F# 4.6 language:

• Anonymous Record types have been added to the language, including full tooling support and the ability to emit them types into JavaScript objects via the Fable compiler.
• ValueOption type and ValueOption module function parity with Option type.
• tryExactlyOne function for arrays, lists, and sequences, contributed by Grzegorz Dziadkiewicz.

F# compiler and FSharp.Core improvements

The F# and compiler and FSharp.Core have seen numerous improvements, especially from open source contributors:

• fsi.exe and fsc.exe now defaults to .NET Framework 4.7.2, allowing the loading of components targeting this framework or lower (#4946).
• We optimized methods on structs and struct records to perform as well as methods on classes and class-based records (#3057).
• We optimized the emitted IL for combined Boolean logic in F# code (#635).
• We've optimized the use of + with strings in F# to call the minimal amount of String.Concat calls as possible (#5560).
• We fixed an issue in the FSharp.Core package where some extra directories with test assets were included. FSharp.Core 4.5.5 and 4.6.1 should have the fix (#5814).
• When a user-defined attribute does not inherit from the Attribute class, you will now receive a warning, by Vasily Kirichenko.
• The AssemblyInformationVersionAttribute value in a project file now supports arbitrary values to support scenarios such as SourceLink (#4822).
• A bug where illegal syntax with Active Patterns would cause an internal compiler error has been fixed by Steffen Forkmann (#5745).
• A bug where the Module suffix was erroneously added to a module in a recursive module to match a type where the only difference is a generic parameter was fixed by BooksBaum (#5794).
• An improvement to the error message when type parameters are not adjacent to a type name has been improved by Alan Ball (#4183).
• The uint16 literal suffix is listed correctly in the error messages for invalid numeric literals, by Teo Tsirpanis (#5712).
• Error messages for computation expressions no longer state async in the message and instead refer to "computation expression(s)", by John Wostenberg (#5343).
• An error message when incorrectly referencing .dlls in F# interactive was fixed by Bartoz Sypytkowski (#5416).
• A bug where Statically Resolved Type Parameters couldn't handle calling a member that hides an inherited member was fixed by Victor Peter Rouven Müller (#5531).
• Various smaller performance improvements to the compiler have been added by Steffen Forkmann and Robert Jeppesen.

F# performance improvements

Another big focus area for F# in Visual Studio 2019 has been performance for medium and large solutions. We addressed some very long-standing issues, some of which dating back to the very first edition of F# tools for Visual Studio. We also got some help from the excellent F# open source community.

• We've revamped how the F# language service is initialized by Roslyn. Type colorization for larger solutions should generally appear sooner.
• We changed our representation of source text to avoid large allocations over time, especially with bigger files (#5935, #5936, #5937, #4881).
• We changed our build caches for small edits to files to use significantly less memory (#6028).
• We modified a compiler feature that suggests names when unrecognized tokens are typed to only compute these suggestions on-demand, resulting in significant CPU and memory reductions when typing slowly in larger solutions (#6044).
• We changed IntelliSense so that it will no longer show symbols from unopened namespaces by default. This notably improves performance for IntelliSense in projects with many references. This feature can be turned back on in the settings via Tools > Options > Text Editor > F# > IntelliSense.
• We improved memory usage when using Type Providers to generate very large amounts of provided types in a completion list (#5599).
• A reduction to CPU and memory usage to an internal string comparison algorithm for suggesting unrecognized names has been fixed by Avi Avni (#6050).
• A notable source of large string allocations, particularly for IDE tooling, was fixed by Avi Avni (#5922).
• A notable source of Large Object Heap allocations coming from computing IntelliSense has been fixed by Chet Husk (#6084)

F# tooling improvements

In addition to performance improvements, various other improvements to F# tooling for Visual Studio 2019 have been made:

• The Add open statement code fix will now default to adding the open statement at the top of the file.
• We fixed a bug where match! in user code invalidated structure guidelines and code outlining nodes for subsequent scopes (#5456).
• The editor will now correctly color byref, outref, and ref values as record fields with the mutable value colorization (#5579).
• We fixed a bug where the rename refactoring did not recognize the ' character in symbol names (#5604).
• We've fixed a longstanding bug where renaming F# script files resulted in a loss of colorization data (#1944).
• We cleaned up IntelliSense so that it doesn't show unrelated items in the list when pressing backspace.
• With "Smart" indentation on, pasting F# code into the editor will now format it to match an appropriate scope based on the current cursor position, implemented by Saul Rennison (#4702).
• An issue where F# editor options weren't syncing has been fixed by Jakob Majocha (#5997, #5998).
• A bug where IntelliSense in a constructor within an inherit clause wouldn't show the primary constructor has been fixed by Eugene Auduchinok (#3699)
• Various smaller improvements to the F# language service have been made by Eugene Auduchinok

F# open source infrastructure

We've fully migrated the F# and F# tools codebase to use the .NET SDK. This dramatically simplifies the contribution process for developers, especially if they are not using Windows. Additionally, Jakob Majocha has helped in cleaning up documents for new contributors in light of the changes to the codebase.

Visual Studio 15.9

You can find all tracked VS 15.9 items in the 15.9 milestone.

F# Compiler

• Fix (#4637) - Can't debug FCS when compiled with portable pdb debug symbols, by Jason Imison.
• Fix (#5355) - We fixed a bug where extension methods that take byref values could mutate an immutable value.
• Fix (#5446) - We improved the compile error information for overloads on byref/inref/outref, rather than displaying the previously obscure error.
• Fix (#5354) - Optional Type Extensions on byrefs are now disallowed entirely. They could be declared previously, but were unusable, resulting in a confusing user experience.
• Fix (#5294) - We fixed a bug where CompareTo on a struct tuple and causing a type equivalence with an aliased struct tuple would result in a runtime exception.
• Fix (#5621) - We fixed a bug where use of System.Void in the context of authoring a Type Provider for .NET Standard could fail to find the System.Void type at design-time.
• Fix (#5468) - We fixed a bug where an internal error could occur when a partially applied Discriminated Union constructor is mismatched with an annotated or inferred type for the Discriminated Union.
• Fix (#5540) - We modified the compiler error message when attempting to take an address of an expression (such as accessing a property) to make it more clear that it violates scoping rules for byref types.
• Fix (#5536) - We fixed a bug where your program could crash at runtime when partially applying a byref type to a method or function. An error message will now display.
• Fix (#5459) - We fixed an issue where an invalid combination of a byref and a reference type (such as byref<int> option) would fail at runtime and not emit an error message. We now emit an error message.

F# Tools for Visual Studio

• Fix (#5657) - We resolved an issue where metadata for F# assemblies built with the .NET Core SDK was not shown in file properties on Windows. You can now see this metadata by right-clicking an assembly on Windows and selecting Properties.
• Fix (#5615) - We fixed a bug where use of module global in F# source could cause Visual Studio to become unresponsive.
• Fix (#5515) - We fixed a bug where extension methods using inref<'T> would not show in completion lists.
• Fix (#5514) - We fixed a bug where the TargetFramework dropdown in Project Properties for .NET Framework F# projects was empty.
• Fix (#5507) - We fixed a bug where File | New Project on a .NET Framework 4.0 project would fail.

F# OSS Build

• Feature (#5027) - Set VisualFSharpFull as the default startup project, by Robert Jeppesen.

Visual Studio 15.8.5

• Fix (#5504) - Internal MSBuild Error when building non-.NET SDK projects with MSBuild parallelism
• Fix (#5518) - Visual Studio-deployed components are not NGEN'd
• Fix (Devcom 322883) - FSharp.Core 4.5.0.0 binary is deployed to FSharp.Core 4.4.3.0 location

All other closed issues for the VS 15.8 release can be found here.

F# 4.5

We introduced the F# language version 4.5 with this release. This also corresponds with the new 4.5.x family of FSharp.Core (the F# core library). You can read the specs for each of these changes in the F# RFC repository. There are also many improvements to F# tools for Visual Studio with this release.

Releases

• Visual Studio 2017 update 15.8
• .NET Core SDK version 2.1.400 or higher

Language features

• Support for voidptr
• NativePtr.ofVoidPtr and NativePtr.toVoidPtr support
• New types: inref<'T>, outref<'T> to represent read-only and write-only byrefs
• Support for IsByRefLike structs
• Support for IsReadOnly structs
• Full support for production and consumption of byref returns
• Support for extension methods for byref/inref/outref
• Support for match! in computation expressions
• Relaxed upcast requirements for yield in sequence, list, and array expressions
• Relaxed indentation requirements for list and array expressions
• Enumeration cases emitted as public
• Various bug fixes with byref programming

FSharp.Core features

• Version aligned to 4.5.x for the NuGet package and 4.5.0.0 for the binary
• Improved strack traces for async { } so that user code can now be seen
• Support for ValueOption<'T>
• Support for TryGetValue on Map

Compiler improvements

Improvements to the F# compiler in addition to the previously-mentioned language features are in F# 4.5. These include:

• Restored ability to inherit from FSharpFunc
• Removed ~2.2% of all allocations in the F# compiler
• F# reference normalization support for user control of transitive assembly references written to an output file
• Respecting WarningsNotAsErrors
• Error message improvement when branches of a pattern match do not return the same type
• Respecting #nowarn "2003"
• Other smaller performance improvements and many bug fixes

Tooling improvements

Significant improvements in the F# tools, such as performance enhancements and some new editor features are included this release. As always, with a large number of contributions from the F# open source community. Here are the highlights:

• We improved IntelliSense performance for .NET SDK-style projects of all forms, including those that use multi-targeting.
• A community-driven effort to analyze and improve IntelliSense performance for very large files was contributed by Vasily Kirichenko, Steffen Forkmann, and Gauthier Segay. IntelliSense in very large files (10k+ lines of code) is roughly twice as fast now.
• The warning for an outdated FSharp.Core (despite the package being installed) is no longer present in .NET SDK-style projects.
• The description tooltip that displays XML documentation for a member after . in IntelliSense no longer times out after 10 seconds.
• A bug where you could not set breakpoints in object constructor arguments has been fixed.
• A bug where a renamed symbol would be duplicated when it is a generic parameter has been fixed.
• Templates for .NET Framework (classic F# templates) now consume FSharp.Core from a NuGet package, to align with .NET SDK F# templates.
• Automatic, transactional brace completion is now available for (), [], {}, [||], and [<>] brace pairs. We did this work in collaboration with Gibran Rosa.
• You can now go to definition with Ctrl + Click on an F# symbol. The settings for this gesture are also respected in the Tools > Options window.
• The IntelliSense performance UI has been modified to allow configuration of stale typecheck information for various IDE features. Explanations for each option are now present in tooltips for the settings.
• Brace match highlighting now correctly highlights braces, completed in collaboration with Vasily Kirichenko.
• Go to definition now navigates correctly when a type is defined recursively, contributed by Vasily Kirichenko.
• A bug where an auto-imported namespace wasn't opened when the top of a file was empty has been fixed by Vasily Kirichenko.
• A bug where printf specifiers that contained dots were miscolored has been fixed by Vasily Kirichenko.
• A bug where all opens were considered unused inside of a recursive module has been fixed by Vasily Kirichenko.
• Autocompletion for attributes now only suggests options that are actually attributes, contributed by Vasily Kirichenko.
• Signature Help tooltips are now generated for Type Provider static parameters at the constructor call site, contributed byVasily Kirichenko.
• A bug where value types used as units of measure were colored as reference types has been fixed by Vasily Kirichenko.
• A bug where semantic colorization could disappear for some files while scrolling has been fixed by Vasily Kirichenko. There is now an experimental CodeLens implementation, contributed by Victor Peter Rouven Müller. You can turn it on in Options > Text Editor > F# > Code Lens.
• A bug where the F# compiler service would incorrectly elide the module names in XML documentation has been fixed by Sebastian Urban.
• Code that uses Dictionary with ContainsKey and subsequent Item calls has been changed to use TryGetValue, by Eugene Auduchinok.
• Jakob Majoka also contributed in the process of consuming a different API for FSharpToolTip.

Infrastructure, Packaging, and Open Source Improvements

We made the following enhancements to infrastructure, packaging, and our open source contribution experience:

• The F# compiler distributed with Visual Studio no longer installs as a singleton in the F# Compiler SDK location. It is now fully side-by-side with Visual Studio, meaning that side-by-side installations of Visual Studio will finally have truly side-by-side F# tooling and language experiences.
• The FSharp.Core NuGet package is now signed.
• ETW logging has been added to the F# tools and compiler.
• The very large control.fs/control.fsi files in FSharp.Core have been split into async.fs/async.fsi, event.fs/event.fsi, eventmodule.fs/eventmodule.fsi, mailbox.fs/mailbox.fsi, and observable.fs/observable.fsi.
• We added .NET SDK-style versions of our project performance stress test artifacts.
• We removed Newtonsoft.json from our codebase, and you now have one less package downloaded for OSS contributors.
• We now use the latest versions of System.Collections.Immutable and System.Reflection.Metadata.

F# 4.1

Releases

• Visual Studio 2017 updates 15.0 to 15.8 (exclusive)
• .NET Core SDK versions 1.0 to 2.1.400 (exclusive)

Language and Core Library features

• Struct tuples
• Initial support for consuming C#-style ref returns
• Struct record support with the [<Struct>] attribute
• Struct Discriminated Union support with the [<Struct>] attribute
• Result<'TSuccess, 'TFailure> type, with supporting functions in FSharp.Core
• Support for the fixed keyword to pin a pointer-style local to the stack
• Underscores in numeric literals
• Caller Info Attribute Argument support
• namespace rec and module rec to support mutually referential types and functions within the same file
• Implicit "Module" suffix added to modules that share the same name as a type
• Tuple equality for F# tuples and System.Tuple

Compiler improvements

• Support for generating Portable PDBs
• Significant improvements to error messages, particularly to aid with suggestions
• Performance improvements
• Interoperability improvements
• Support for generating F# AssemblyInfo from properties for .NET SDK projects
• --debug:full support for F# on .NET Core on Windows
• MakeTuple support for struct tuples
• Warnings are forwarded when searching for method overloads
• Support for emitting an enum-specific warning when pattern matching over one
• Many smaller bug fixes

FSharp.Core features

• Support for NativePtr.ByRef
• Support for Async.StartImmediateAsTask
• Support for Seq.transpose/Array.transpose/List.transpose
• IsSerializable support for Option and Async<'T>
• Many smaller bug fixes

IDE features for F# tools in Visual Studio

Most items here contributed by community members.

• Default installation of F# wherever .NET Core is installed
• Significant memory reductions in F# tooling
• IntelliSense Filters and Glyphs
• Support for Go to All
• Find all Reference support
• In-memory cross-project references support
• QuickInfo supports type colorization
• QuickInfo supports navigable links that will invoke Go to Definition
• Inline Rename support
• Go to Definition from F# to C# support
• Semantic document highlighting for selected symbols
• Support for Structured Guidelines and code outlining, which is toggleable
• Support for EditorBrowsable(EditorBrowsableState.Never)
• Code fix for making Record and Discriminated Union case labels upper-case
• Code fix to make suggestions for an unknown identifier
• Code fix for prefixing or replacing an unused value with an underscore
• Code fix to add the new keyword to a disposable type
• Code fix to add an open statement at the top for a symbol coming from an unopened namespace or module
• Code fix to simplify a name by removing unnecessary namespace qualifiers
• Graying out unused values in the editor
• Colorized fsi.exe when ran as a standalone console application
• Autocompletion support, including symbols from unopened namespaces
• Colorization for mutable values to distinguish them from immutable values
• Support for move up/down on solution folder nodes
• Support for Blue (High Contrast) theming
• Full support for .NET Core and .NET Standard projects, with the ability to create new ASP.NET Core projects in F#
• Full support for ASP.NET Web SDK tooling, such as Azure publish UI, for F# projects
• Property page auto-sizing support for different monitors
• Smart indentation support which auto-indents based on scope and auto-deindents for bracket-like characters
• XML documentation comment width scaling to prevent it running horizontally off the screen
• Multiple settings pages to modify tooling settings
• Support for Drag and Drop across folders
• Support for nightly builds of the tools
• Expanded debugger view for lists from 50 items to 5000 items
• Support for Optimization APIs in the compiler service
• Support for IsNameGenerated in the F# symbols API

FSharp Compiler Service Versions Release notes

37.0.0

This release bring a number of new changes, including a massive enhancement to SemanticClassification types thanks to @cartermp.

From dotnet/fsharp:333eb82c8..d9e070a9d:

• now allows for multiple implementations of generic interfaces (preview feature) (thanks @0x53A!)
• the default assembly set for script resolution now includes System.Numerics (thanks @KevinRansom)
• #r nuget package resolution is now committed eagerly, instead of delayed (thanks @KevinRansom)
• reduced allocations for some strings in the compiler (thanks @kerams)
• better printing for SRTP constraints (thanks @abelbraaksma/@realvictorprm)
• more expressive DUs for semantic classification (thanks @cartermp)
• remove legacymsbuildreferenceresolver (thanks @KevinRandom)
• supply witnesses for op_UnaryPlus (thanks @TIHan)
• clean up CE classifications (thanks @cartermp)
• Fixed tostring/equality for StringText (thanks @deviousasti)
• Fixed error text for FS0874
• Disallow assignment to C# Const/Readonly properties (thanks @baronfel)
• Allow Int64.MinValue as a valid nativeint literal (thanks @abelbraaksma)
• Enhancements to the nameof feature (preview feature)
• String interpolation (preview feature)

36.0.3

This is a small bugfix release that fixes a nuspec package dependency issue with Sourcelink

36.0.2

This is a small bugfix release that I'm making primarily to publish a version of FCS with sourcelink enabled, so that tooling users can make use of that information.

From dotnet/fsharp:079276b4b..37d0cccec:

• Fixes for do! handling in computation expressions (thanks @baronfel)
• Add missing versions in FCS' Interactive header (thanks @nightroman)
• Support Source-translation in match! expressions (thanks @baronfel)
• Ensure stack traces from uncaught exceptions in CEs are maintained (thanks @NinoFloris)
• Better handling of inline in witness-passing codepaths (thanks @dsyme)
• Enable publishing of FCS with sourcelink (thanks @baronfel)
• Extend nameof to support naming generic parameters (nameof<'t>) and instance members (nameof(Unchecked.defaultof<C>.Property)) (thanks @dsyme)

36.0.1

From dotnet/fsharp:522dd906c..16bca5aef:

• Fixes to attribute range parsing (thanks @auduchinok)
• Added nested exception details to Type Provider load errors (thanks @dsyme)
• Improved error messages around unknown identifiers in patterns (thanks @jbeeko)
• Better dependency probing behavior with Facade assemblies (thanks @KevinRansom)
• APIs for programmatically adding and retrieving bindings in an FSI session (thanks @TIHan)
• Optional parameter on FSharpChecker.FindBackgroundReferencesInFile API to allow for stale results (thanks @TIHan)
• Better tooltips for function arguments (thanks @mcon)
• Many performance tweaks to various compiler function implementations (thanks @forki)
• Typo fixes in the AST (thanks @auduchinok)
• Better IL emitted for usages of static members as System.Action (thanks @MoFtZ)
• Allow for indexers to specify a type annotation (thanks @TIHan)
• Allow languages/scripts that have no notion of upper-case to use their characters for DU identifiers (thanks @KevinRansom)
• more optimized comparison/equality for DateTime (thanks @cartermp)
• add support for char for the GenericZero/GenericOne mechanisms (thanks @Happypig375)
• enhancements for the dependencymanager's resolution for native scripts (thanks @KevinRansom)
• more consistent support for type-directed nullable parameters (thanks @dsyme)
• fix FSI's ordering of out-of-order dlls in nuget packages (thanks @KevinRansom)
• New SyntaxTree.Paren syntax node (thanks @auduchinok)
• add SRTP witness solutions (via the new CallWithWitnesses pattern) (thanks @dsyme)

35.0.0

This version bumps the major due to API surface area changes in the AST and TAST. In addition, there's a new package for the built-in Nuget dependency manager for FSI: FSharp.DependencyManager.Nuget

Members are now in SyntaxTree/SyntaxTreeOps and TypedTree/TypedTreeBasics/TypedTreeOps/TypedTreePickle.

From dotnet/fsharp:d1a3d0705..522dd906c:

• Improved error recovery from patterns (thanks @auduchinok)
• Smaller IL Emit for unsigned 64-bit constants (thanks @teo-tsirpanis)
• Improved ProvidedTypes Type generation (thanks @DedSec256)
• Improved CodeLenses provided (thanks @realvictorprm)
• Optimize internal member calculations in PrettyNaming and items lookup (thanks @auduchinok)
• More fixes to compiler internals, ranges, etc (thanks @auduchinok)
• Support for consumption of C# Default Interfaces
• Better encapsulation of ProvidedExpr members (thanks @DedSec256)

34.1.1

From dotnet/fsharp:3777cd4d8..836da28c0:

• Slight tweaks to error messages around numeric literals (Thanks @Happypig375)
• Deny taking native address of an immutable local value (Thanks @TIHan)
• Fixes to reported ranges for wildcard self-identifiers, module abbreviations, nested modules, attributes, nested types, and fields (Thanks @auduchinok)
• Better compiler error recovery for errors in constructor expressions (Thanks @auduchinok)
• Fix handling of F# Options in C# members with regards to nullable type interop (Thanks @TIHan)
• Move dependency handling of native dlls to the DependencyManager (Thanks @KevinRansom)

34.1.0

From dotnet/fsharp:3af8959b6..9d69b49b7:

• set default script TFM to netcoreapp3.1 if none found
• improve C#-nullable and optional interop (RFC FS-1075)
• Add type name to undefined name error if known
• improve printing via %A/fsi
• misc. improvements to DependencyManager
• improve type provider support for .netcoreapp3.1 target frameworks.
• New, optimized find-all-references API with reduced memory usage.
• better error messages for failed overload resolution

34.0.1

Contains commits from 32b124966 to d7018737c from dotnet/fsharp. Notable changes include:

• lowered allocations for large strings and char arrays (notably source file texts)
• improved support for byref-like rules with regards to type abbreviations
• better support for scopes in recursive modules
• better location of .net core reference assemblies
• lowered allocations for several internal compiler structures
• better error messages for anonymous record mismatches
• FSharpChecker learned how to keep background symbol uses
• The tool for parsing projects was removed
• Better support for consuming C# in-ref parameters
• new services around simplifying names and finding unused declarations
• package management in scripts (in preview)
• and-bang syntax support (in preview)

33.0.1

Integrate dotnet/fsharp from 4f5f08320 to 7b25d7f82. Notable changes include:

• Addition of the FsharpUnionCase.HasFields property
• FCS builds entirely on .Net Core now
• Better debug information for ranges
• Support for Literal values in signature files
• Using memory-mapped files cross-platform to read IL.

33.0.0

Integrate dotnet/fsharp from 48f932cf8 to 085985140. Notable changes include:

allowing '_' as a self-identifier
events for FSI evaluation lifecycle events
enhancements to FSI return-values
fixed parsing for langversion CLI arguments
allow cancellation of FSI interactions
ToString fixes for value options
Fixes for code generation in autogenerated members for very large records
make ranges of member declarations capture the entire member
improve error recovery in the parser
improve logic for auto-detecting framework assemblies for FSI

32.0.0

• integrate dotnet/fsharp from e1b8537ee to 48f932cf8
• notable changes include:
• (preview) nameof
• (preview) open static classes
• Fixed 64-bit integer literal parsing
• Better exhaustiveness checking for byte and sbyte pattern matches
• Better native resource handling
• Script-host assembly load events

31.0.0

• Integrate dotnet/fsharp from 5a8f454a1 to 05c558a61
• Notable changes include:
  • Removal of the Microsoft.FSharp.Compiler.SourceCodeServices namespace
  • A new API for determining if an identifier needs to be quoted is available: FSharp.Compiler.LexHelp.FSharpKeywords.DoesIdentifierNeedQuotation
  • Enhancements to the correctness of PDBs
  • Better string formatting of records and values
  • More stack overflow fixes in the compiler
  • Inline IL parsing error handling
  • LeafExpressionConverter handles struct tuples
  • FSharpChecker now can parse a file without caching: ParseFileNoCache

30.0.0

• Integrate dotnet/fsharp from 25560f477 to 5a8f454a1
• Notable improvements include:
  • performance improvements
  • FCS APIs for FSComp and Implement Interface
  • line directive handling
  • improved performance when computing quick fix suggestions

29.0.1

• Fix versioning of the assembly

29.0.0

• Integrate visualfsharp master from 165b736b9 (2019-03-29) to 25560f477 (2019-05-24)
• Notable improvements include:
  • Improved Portable PDB debugging
  • Misc IL generation fixes
  • Representing inlined mutable variables in the AST
  • Moving on from net46 targeting
  • Fixes for anonymous record generation
  • Dependency updates
  • Checking for constructors in FSharpMemberOrFunctionOrValue
  • Fix unused opens false positive for record fields

28.0.0

• Integrate visualfsharp master from efb57cf56 to 8dfc02feb
• Notable improvements include:
  • XmlDoc fixes for overloads
  • Fixes for deterministic compilation
  • Improved tail-recursion when processing large expressions
  • Better tooltip detection for operators with constraints
  • FSharp.Compiler.Service nuget now uses net461, netstandard2.0 and FSharp.Core 4.6.2
  • updated lexer and parser implementations to reduce stackoverflow likelihood on .net core

27.0.1

• Integrate visualfsharp master from 5a5ca976ec296d02551e79c3eb8e8db809e4304d to 2c8497bb097d5c5d3ef12f355594873838a48494
• Notable improvements include:
  • Anonymous Record support for expressions
  • Union Case Naming fixes
  • Trimming of the nuget package dependencies from 26.0.1

26.0.1

• Integrate visualfsharp master to 99e307f3a3ef2109ba6542ffc58affe76fc0e2a0

25.0.1

• Integrate visualfsharp master to 15d9391e78c554f91824d2be2e69938cd811df68

24.0.1

• Integrate visualfsharp master to 59156db2d0a744233d1baffee7088ca2d9f959c7

23.0.3

• Clarify package authors

23.0.1