Merge branch 'main' into revert-19710-ilxgen-fallback

Author: majocha

azure-pipelines.yml

@@ -126,6 +126,8 @@ extends:
             variables:
             - name: _SignType
               value: Real
+            - name: BclPackageVersion
+              value: '10.0.13'
             steps:
             - checkout: self
               clean: true
@@ -143,6 +145,11 @@ extends:
                       /p:OfficialBuildId=$(BUILD.BUILDNUMBER)
                       /p:VisualStudioDropName=$(VisualStudioDropName)
                       /p:GenerateSbom=true
+                      /p:SystemCollectionsImmutablePackageVersion=$(BclPackageVersion)
+                      /p:SystemCompositionPackageVersion=$(BclPackageVersion)
+                      /p:SystemDiagnosticsDiagnosticSourcePackageVersion=$(BclPackageVersion)
+                      /p:SystemReflectionMetadataPackageVersion=$(BclPackageVersion)
+                      /p:SystemSecurityCryptographyXmlPackageVersion=$(BclPackageVersion)
               env:
                   NativeToolsOnMachine: true
                   FSHARP_CACHE_OVERRIDE: 256

docs/release-notes/.FSharp.Compiler.Service/11.0.200.md

@@ -4,6 +4,7 @@
 * Completion: respect EditorBrowsableAttribute ([PR #20729](https://github.com/dotnet/fsharp/pull/20729))
 * Runtime-async sequences allow awaits inside `try/with` bodies, filters and handlers, and reject overlapping `MoveNextAsync` calls. ([PR #20655](https://github.com/dotnet/fsharp/pull/20655))
 * F# Interactive gains a JSON-RPC server mode, `--fsi-server-jsonrpc:<pipe name>`, in which a host submits interactions over a named pipe and receives structured results — diagnostics with positions, escaping exceptions, the values each interaction bound, and the session's own process id — instead of recovering them by looking for a `SERVER-PROMPT>` marker in the output text. Program output continues to flow through the redirected console streams. The pipe admits only the user running the session; `--fsi-server-client-pid:<pid>` names the host process whose exit ends the session. `FsiEvaluationSession` exposes both options as `JsonRpcServerPipeName` and `JsonRpcClientProcessId`. The mode is part of the .NET fsi only. ([PR #20396](https://github.com/dotnet/fsharp/pull/20396))
+* Include individual active-pattern cases from unopened modules in pattern completion. ([PR #20719](https://github.com/dotnet/fsharp/pull/20719))
 
 ### Fixed
 
@@ -38,8 +39,10 @@
 ### Changed
 
 * Revert the IlxGen fallback from [PR #19710](https://github.com/dotnet/fsharp/pull/19710) that silently defaulted type variables missing from the IL type environment. Code generation reports FS0073 again instead of emitting wrong IL, which had masked [Issue #20812](https://github.com/dotnet/fsharp/issues/20812). ([PR #20821](https://github.com/dotnet/fsharp/pull/20821))
+* Debugger: emit a call for a self tail call in non-optimized builds ([PR #20782](https://github.com/dotnet/fsharp/pull/20782))
 * Remove the unused internal `--test:NoErrorText` switch and its argument-only diagnostic formatting. ([PR #20742](https://github.com/dotnet/fsharp/pull/20742))
 * Assign seven previously preview-only features to [F# 11.2](https://fsharp.github.io/fsharp-compiler-docs/release-notes/Language.html#11.2), now the default language version. `default`, `latest`, and `latestmajor` select F# 11.2; explicit `11` and `11.0` retain F# 11.0 behavior. Preview SDK projects use the same compiler default unless `LangVersion` is explicitly set. `FromEndSlicing` remains preview-only. ([PR #20617](https://github.com/dotnet/fsharp/pull/20617))
 * Add `SynExceptionDefnReprTrivia` with the range of the `exception` keyword to `SynExceptionDefnRepr`. ([Fantomas Issue #3483](https://github.com/fsprojects/fantomas/issues/3483), [PR #20612](https://github.com/dotnet/fsharp/pull/20612))
 * Add `WhenKeyword` to `SynMatchClauseTrivia` with the range of the `when` keyword in match clauses. ([PR #20734](https://github.com/dotnet/fsharp/pull/20734))
 * Add `OfKeyword` to `SynUnionCaseTrivia` with the range of the `of` keyword in union cases and exception definitions. ([PR #20635](https://github.com/dotnet/fsharp/pull/20635))
+* Optimizer: key debug inline specializations on type arguments and witnesses ([PR #20844](https://github.com/dotnet/fsharp/pull/20844))

docs/release-notes/.FSharp.Core/11.0.200.md

@@ -4,6 +4,7 @@
 
 ### Fixed
 
+* Correct `FSharpValue.PreComputeTuplePropertyInfo` to report that struct tuples store elements in fields, not properties, and recommend supported tuple readers instead of reporting a valid index as out of range. ([Issue #20801](https://github.com/dotnet/fsharp/issues/20801), [PR #20815](https://github.com/dotnet/fsharp/pull/20815))
 * Quotation debug text from `Expr.ToString()`, `Expr.ToString(full)`, and `%A` now prints struct tuple construction as `NewStructTuple`; reference tuples remain `NewTuple`. ([Issue #20800](https://github.com/dotnet/fsharp/issues/20800), [PR #20814](https://github.com/dotnet/fsharp/pull/20814))
 
 ### Changed

docs/release-notes/.VisualStudio/18.vNext.md

@@ -1,5 +1,6 @@
 ### Added
 
+* Suggest active-pattern cases from unopened modules and offer valid Add Open and qualification edits. ([PR #20719](https://github.com/dotnet/fsharp/pull/20719))
 * Add maintainer-requested F# Apex Visual Studio integration tests on DartLab-1ES CloudTest, using PR pipeline definitions pinned to an explicitly requested commit SHA. ([PR #20625](https://github.com/dotnet/fsharp/pull/20625))
 * Code-fixes for FS3888 (compiler-semantic attribute on the `.fs` but not the `.fsi`): copy the attribute into the `.fsi`, or remove it from the `.fs`. ([Issue #19560](https://github.com/dotnet/fsharp/issues/19560), [PR #19880](https://github.com/dotnet/fsharp/pull/19880))
 * Expand `<inheritdoc/>` in IDE tooltips, completion, and signature help, inheriting XML documentation from base classes, interfaces, overridden members, and constructors. ([Issue #19175](https://github.com/dotnet/fsharp/issues/19175), [PR #19188](https://github.com/dotnet/fsharp/pull/19188))
@@ -23,6 +24,7 @@
 * Fix `NotSupportedException` in the memory-mapped-file optimization when copying `ReadOnlyMemory` into `MemoryMappedFileViewStream`. ([Issue #20263](https://github.com/dotnet/fsharp/issues/20263))
 * Reduce allocations in the VS project options reactor: the command-line options and project options caches and the mailbox reply payloads now hold struct tuples, and `IProjectSite.CompilationBinOutputPath` returns `string voption` picked with a new `Array.tryPickV`. ([PR #20413](https://github.com/dotnet/fsharp/pull/20413))
 * Build a single-file project's `OtherOptions` reference flags with one array comprehension instead of two `Array.ofSeq` calls and an `Array.append`. ([PR #20499](https://github.com/dotnet/fsharp/pull/20499))
+* Keep concurrent completion requests from mixing their suggestion lists. ([PR #20719](https://github.com/dotnet/fsharp/pull/20719))
 * Fix syntax coloring being lost for a whole file when one symbol resolves into metadata that could not be read. ([Issue #20269](https://github.com/dotnet/fsharp/issues/20269), [PR #20274](https://github.com/dotnet/fsharp/pull/20274))
 * Go To Definition into an F# project built with a path map (`DeterministicSourcePaths` or `PathMap`) opens its source instead of a generated signature: the IDE no longer applies `--pathmap` to the project options it checks with. ([PR #20470](https://github.com/dotnet/fsharp/pull/20470))
 * Fix completion after a closed backticked identifier on the same line. ([PR #20785](https://github.com/dotnet/fsharp/issues/20785))
@@ -31,6 +33,7 @@
 
 * Rename "inline hints" to "inlay hints" in VS options for consistency with industry terminology. ([PR #19318](https://github.com/dotnet/fsharp/pull/19318))
 * Unused analyzers: disable in VS when file has errors ([PR #19892](https://github.com/dotnet/fsharp/pull/19892))
+* Reuse current-project symbol catalogues for completion and Add Open requests that share a file-check result. ([PR #20719](https://github.com/dotnet/fsharp/pull/20719))
 * Move to Roslyn's unified ExternalAccess library ([PR #20099](https://github.com/dotnet/fsharp/pull/20099))
 * Remove trailing whitespace from source files. No functional change: whitespace inside string literals and inactive `#if` regions is preserved. ([PR #20355](https://github.com/dotnet/fsharp/pull/20355))
 * The VS project options reactor keeps single-file and script project options in a named record instead of a five-place tuple, and its text-view subscription plumbing uses `voption` instead of `option`. ([PR #20455](https://github.com/dotnet/fsharp/pull/20455))

eng/Packages.props

@@ -30,7 +30,7 @@
     <!-- Security: pin the transitive MessagePack (pulled via StreamJsonRpc) to a patched version.
          Versions < 2.5.301 have known vulnerabilities (NU1902/NU1903). Transitive pinning applies it
          wherever StreamJsonRpc is used (FSharp.Compiler.LanguageServer and the CLASP.Framework.Proxy). -->
-    <PackageVersion Include="MessagePack" Version="2.5.302" />
+    <PackageVersion Include="MessagePack" Version="2.5.303" />
     <PackageVersion Include="Microsoft.Build" Version="$(MicrosoftBuildVersion)" />
     <PackageVersion Include="Microsoft.Build.Framework" Version="$(MicrosoftBuildFrameworkVersion)" />
     <PackageVersion Include="Microsoft.Build.Tasks.Core" Version="$(MicrosoftBuildTasksCoreVersion)" />

eng/Version.Details.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Dependencies>
-  <Source Uri="https://github.com/dotnet/dotnet" Mapping="fsharp" Sha="a69d27567bd8be379e504329c965b9ca3fdf53fd" BarId="337438" />
+  <Source Uri="https://github.com/dotnet/dotnet" Mapping="fsharp" Sha="ee344f85ef890dd92974e9b93d75906f1f8c39f3" BarId="337683" />
   <ProductDependencies>
     <Dependency Name="Microsoft.Build" Version="18.13.0-1.26516.14">
       <Uri>https://github.com/dotnet/msbuild</Uri>

src/Compiler/Checking/NameResolution.fsi

@@ -1009,5 +1009,7 @@ val GetVisibleNamespacesAndModulesAtPoint:
 
 val IsItemResolvable: NameResolver -> NameResolutionEnv -> range -> AccessorDomain -> string list -> Item -> bool
 
+val ItemIsUnseen: AccessorDomain -> TcGlobals -> ImportMap -> range -> allowUnseen: UnseenItems -> Item -> bool
+
 val TrySelectExtensionMethInfoOfILExtMem:
     range -> ImportMap -> TType -> TyconRef * MethInfo * ExtensionMethodPriority -> MethInfo option

src/Compiler/CodeGen/IlxGen.fs

@@ -4606,7 +4606,10 @@ and GenApp (cenv: cenv) cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel =
 
     match (stripDebugPoints f, tyargs, curriedArgs) with
     // Look for tailcall to turn into branch
-    | Expr.Val(v, _, _), _, _ when IsBranchTailcall cenv eenv (v, tyargs, curriedArgs) sequel ->
+    | Expr.Val(v, _, _), _, _ when
+        cenv.options.localOptimizationsEnabled
+        && IsBranchTailcall cenv eenv (v, tyargs, curriedArgs) sequel
+        ->
         let kind, mark = ListAssoc.find g.valRefEq v eenv.innerVals // already checked above in when guard
 
         // Generate the arguments for the direct tail call.
@@ -4803,7 +4806,11 @@ and GenApp (cenv: cenv) cgbuf eenv (f, fty, tyargs, curriedArgs, m) sequel =
                 if isNil laterArgs && not isSelfInit then
                     let isDllImport = IsValRefIsDllImport g vref
                     let hasByrefArg = mspec.FormalArgTypes |> List.exists IsILTypeByref
-                    let makesNoCriticalTailcalls = vref.MakesNoCriticalTailcalls
+
+                    let makesNoCriticalTailcalls =
+                        vref.MakesNoCriticalTailcalls
+                        && not (IsBranchTailcall cenv eenv (vref, tyargs, curriedArgs) sequel)
+
                     let hasStructObjArg = (boxity = AsValue) && takesInstanceArg
 
                     CanTailcall(

src/Compiler/FSharp.Compiler.Service.fsproj

@@ -580,8 +580,6 @@
     <Compile Include="Service\ServiceCompilerDiagnostics.fsi" />
     <Compile Include="Service\ServiceCompilerDiagnostics.fs" />
     <Compile Include="Service\ServiceConstants.fs" />
-    <Compile Include="Service\ServiceDeclarationLists.fsi" />
-    <Compile Include="Service\ServiceDeclarationLists.fs" />
     <Compile Include="Service\ServiceLexing.fsi" />
     <Compile Include="Service\ServiceLexing.fs" />
     <Compile Include="Service\ServiceParseTreeWalk.fsi" />
@@ -598,6 +596,8 @@
     <Compile Include="Service\FSharpParseFileResults.fs" />
     <Compile Include="Service\ServiceParsedInputOps.fsi" />
     <Compile Include="Service\ServiceParsedInputOps.fs" />
+    <Compile Include="Service\ServiceDeclarationLists.fsi" />
+    <Compile Include="Service\ServiceDeclarationLists.fs" />
     <Compile Include="Service\ServiceAssemblyContent.fsi" />
     <Compile Include="Service\ServiceAssemblyContent.fs" />
     <Compile Include="Service\ServiceXmlDocParser.fsi" />

src/Compiler/Optimize/Optimizer.fs

@@ -443,7 +443,7 @@ type cenv =
 
       realsig: bool
 
-      specializedInlineVals: HashMultiMap<Stamp, TType * Expr>
+      specializedInlineVals: HashMultiMap<Stamp, TType list * Expr>
 
       forcedInlineVals: Dictionary<Stamp, bool>
 
@@ -462,12 +462,12 @@ type IncrementalOptimizationEnv =
     { /// An identifier to help with name generation
       latestBoundId: Ident option
 
-      /// Prevents recursive inlining/specialization. Maps lambda ID to a list of specialized types
+      /// Prevents recursive inlining/specialization. Maps lambda ID to a list of instantiations
       /// currently being processed. An empty list means "block unconditionally" (used by normal
       /// inlining and non-concrete debug specialization). A non-empty list means "block only these
-      /// specific type specializations" (used by concrete debug specialization, allowing different
-      /// type instantiations of the same function to proceed).
-      dontInline: Map<Stamp, TType list>
+      /// specific instantiations" (used by concrete debug specialization, allowing different
+      /// instantiations of the same function to proceed).
+      dontInline: Map<Stamp, TType list list>
 
       /// Recursively bound vars. If an sub-expression that is a candidate for method splitting
       /// contains any of these variables then don't split it, for fear of mucking up tailcalls.
@@ -2749,6 +2749,29 @@ let FloatInlineIfLambdaCaptures g expr =
         rebind bind.Expr
     | _ -> expr
 
+let private traitConstraintsOfTyarg tyarg =
+    match tyarg with
+    // The witnesses selected for a call live in the constraint cells of its solved type arguments.
+    | TType_var(tp, _) ->
+        tp.Constraints
+        |> List.choose (function
+            | TyparConstraint.MayResolveMember(traitInfo, _) -> Some traitInfo
+            | _ -> None)
+    | _ -> []
+
+let private solvedTraitEquiv g aenv (traitInfo1: TraitConstraintInfo) (traitInfo2: TraitConstraintInfo) =
+    traitsAEquiv g aenv traitInfo1 traitInfo2
+    && traitSlnAEquiv g aenv traitInfo1.Solution traitInfo2.Solution
+
+let private tyargEquiv g aenv tyarg1 tyarg2 =
+    typeAEquiv g aenv tyarg1 tyarg2
+    && List.lengthsEqAndForall2 (solvedTraitEquiv g aenv) (traitConstraintsOfTyarg tyarg1) (traitConstraintsOfTyarg tyarg2)
+
+let private specializationKeyEquiv g tyargs1 tyargs2 =
+    // Under --checknulls the specialized body keeps or drops null guards by the nullness of the type arguments.
+    let aenv = TypeEquivEnv.EmptyWithNullChecks g
+    List.lengthsEqAndForall2 (tyargEquiv g aenv) tyargs1 tyargs2
+
 /// Optimize/analyze an expression
 let rec OptimizeExpr cenv (env: IncrementalOptimizationEnv) expr =
     cenv.stackGuard.Guard(fun () ->
@@ -3950,10 +3973,9 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg
              || (not alwaysInline
                  && vref.ShouldInline
                  && not (shouldForceInlineInDebug cenv env vref)) ->
-        let traits =
+        let hasNoTraits =
             let tps, _ = tryDestForallTy g vref.Type
-            GetTraitConstraintInfosOfTypars g tps
-        let hasNoTraits = traits.IsEmpty
+            GetTraitConstraintInfosOfTypars g tps |> List.isEmpty
 
         // Direct-calling an SRTP callee is only safe when every tyarg is a bare typar: then the
         // callee's SRTP constraints land on the caller's own typars and IlxGen rewrites the
@@ -4027,16 +4049,16 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg
 
             let allTyargsAreConcrete = List.isEmpty freeTypars
 
-            // Proceed with specialization only if this (stamp, type) pair isn't already being
+            // Proceed with specialization only if this (stamp, instantiation) pair isn't already being
             // processed. For concrete type args, allow different type instantiations of the same
             // function (e.g. sum<int, int->int> can call sum<int, int> in its body). For
             // non-concrete type args, never specialize recursively.
             let canSpecialize =
                 match Map.tryFind origLambdaId env.dontInline with
-                | Some tys ->
+                | Some insts ->
                     allTyargsAreConcrete &&
-                    not tys.IsEmpty &&
-                    not (tys |> List.exists (typeEquiv g specLambdaTy))
+                    not insts.IsEmpty &&
+                    not (insts |> List.exists (specializationKeyEquiv g tyargs))
                 | None -> true
 
             if not canSpecialize then
@@ -4046,25 +4068,20 @@ and TryInlineApplication cenv env finfo (valExpr: Expr) (tyargs: TType list, arg
             else
 
             let specialize () =
-                let existingTypes = defaultArg (Map.tryFind origLambdaId argEnv.dontInline) []
-                let types = if allTyargsAreConcrete then specLambdaTy :: existingTypes else []
+                let existingInsts = defaultArg (Map.tryFind origLambdaId argEnv.dontInline) []
+                let insts = if allTyargsAreConcrete then tyargs :: existingInsts else []
                 let env =
                     { argEnv with
-                        dontInline = Map.add origLambdaId types argEnv.dontInline }
+                        dontInline = Map.add origLambdaId insts argEnv.dontInline }
                 OptimizeExpr cenv env specLambda |> fst
 
-            // The type-only cache key does not include selected SRTP witnesses.
-            let canCacheSpecialization =
-                allTyargsAreConcrete &&
-                (hasNoTraits || not (g.langVersion.SupportsFeature LanguageFeature.ExtensionConstraintSolutions))
-
             let specLambdaR =
-                if canCacheSpecialization then
-                    match cenv.specializedInlineVals.FindAll(origLambdaId) |> List.tryFind (fun (ty, _) -> typeEquiv g ty specLambdaTy) with
+                if allTyargsAreConcrete then
+                    match cenv.specializedInlineVals.FindAll(origLambdaId) |> List.tryFind (fun (inst, _) -> specializationKeyEquiv g inst tyargs) with
                     | Some (_, body) -> copyExpr g CloneAll body
                     | None ->
                     let specLambdaR = specialize ()
-                    cenv.specializedInlineVals.Add(origLambdaId, (specLambdaTy, specLambdaR))
+                    cenv.specializedInlineVals.Add(origLambdaId, (tyargs, specLambdaR))
                     specLambdaR
                 else
                     specialize ()