Merge 'dotnet/main' into PrimaryConstructors

.github/CODEOWNERS

@@ -51,3 +51,4 @@ src/Features/**/PublicAPI.Unshipped.txt @dotnet/roslyn-api-owners
 src/EditorFeatures/**/PublicAPI.Unshipped.txt @dotnet/roslyn-api-owners
 
 src/Tools/ExternalAccess/OmniSharp*/ @333fred @joerobich
+src/Tools/ExternalAccess/RazorCompiler @dotnet/roslyn-compiler

Compilers.sln

@@ -165,6 +165,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSha
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestDiscoveryWorker", "src\Tools\TestDiscoveryWorker\TestDiscoveryWorker.csproj", "{FB617466-C4A1-4289-A512-A06182FC779F}"
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "ExternalAccess", "ExternalAccess", "{67B6F694-CA27-4CDE-B1E5-E2B4105A2420}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler", "src\Tools\ExternalAccess\RazorCompiler\Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler.csproj", "{8450EF6B-28BB-4F4D-B005-CD734B476800}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -423,6 +427,10 @@ Global
 		{FB617466-C4A1-4289-A512-A06182FC779F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{FB617466-C4A1-4289-A512-A06182FC779F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{FB617466-C4A1-4289-A512-A06182FC779F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{8450EF6B-28BB-4F4D-B005-CD734B476800}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{8450EF6B-28BB-4F4D-B005-CD734B476800}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{8450EF6B-28BB-4F4D-B005-CD734B476800}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{8450EF6B-28BB-4F4D-B005-CD734B476800}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -499,6 +507,8 @@ Global
 		{48C93F90-8776-4847-96D8-127B896D6C80} = {C65C6143-BED3-46E6-869E-9F0BE6E84C37}
 		{F3D9264A-7CAE-4265-AF48-0C863301F51E} = {32A48625-F0AD-419D-828B-A50BDABA38EA}
 		{FB617466-C4A1-4289-A512-A06182FC779F} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+		{67B6F694-CA27-4CDE-B1E5-E2B4105A2420} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+		{8450EF6B-28BB-4F4D-B005-CD734B476800} = {67B6F694-CA27-4CDE-B1E5-E2B4105A2420}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {6F599E08-A9EA-4FAA-897F-5D824B0210E6}

Compilers.slnf

@@ -44,6 +44,7 @@
       "src\\Test\\PdbUtilities\\Roslyn.Test.PdbUtilities.csproj",
       "src\\Compilers\\Test\\Core\\Microsoft.CodeAnalysis.Test.Utilities.csproj",
       "src\\Tools\\AnalyzerRunner\\AnalyzerRunner.csproj",
+      "src\\Tools\\ExternalAccess\\RazorCompiler\\Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler.csproj",
       "src\\Tools\\Source\\CompilerGeneratorTools\\Source\\BoundTreeGenerator\\CompilersBoundTreeGenerator.csproj",
       "src\\Tools\\Source\\CompilerGeneratorTools\\Source\\CSharpErrorFactsGenerator\\CSharpErrorFactsGenerator.csproj",
       "src\\Tools\\Source\\CompilerGeneratorTools\\Source\\CSharpSyntaxGenerator\\CSharpSyntaxGenerator.csproj",

Roslyn.sln

@@ -519,12 +519,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CommonLanguageSer
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.TestAnalyzerReference", "src\Workspaces\TestAnalyzerReference\Microsoft.CodeAnalysis.TestAnalyzerReference.csproj", "{8A29449D-411E-49E4-B99E-E8428076BB21}"
 EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.CSharp.LanguageServer.Protocol", "src\Features\LanguageServer\Microsoft.CodeAnalysis.CSharp.LanguageServer.Protocol\Microsoft.CodeAnalysis.CSharp.LanguageServer.Protocol.csproj", "{4C1B26EE-465B-4B30-9E50-0285EF7AB035}"
-EndProject
-Project("{778DAE3C-4631-46EA-AA77-85C1314464D9}") = "Microsoft.CodeAnalysis.VisualBasic.LanguageServer.Protocol", "src\Features\LanguageServer\Microsoft.CodeAnalysis.VisualBasic.LanguageServer.Protocol\Microsoft.CodeAnalysis.VisualBasic.LanguageServer.Protocol.vbproj", "{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650}"
-EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "TestDiscoveryWorker", "src\Tools\TestDiscoveryWorker\TestDiscoveryWorker.csproj", "{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler", "src\Tools\ExternalAccess\RazorCompiler\Microsoft.CodeAnalysis.ExternalAccess.RazorCompiler.csproj", "{E5E0BF73-95F7-4BC3-8443-2336C4FF4297}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1271,18 +1269,14 @@ Global
 		{8A29449D-411E-49E4-B99E-E8428076BB21}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8A29449D-411E-49E4-B99E-E8428076BB21}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8A29449D-411E-49E4-B99E-E8428076BB21}.Release|Any CPU.Build.0 = Release|Any CPU
-		{4C1B26EE-465B-4B30-9E50-0285EF7AB035}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4C1B26EE-465B-4B30-9E50-0285EF7AB035}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{4C1B26EE-465B-4B30-9E50-0285EF7AB035}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{4C1B26EE-465B-4B30-9E50-0285EF7AB035}.Release|Any CPU.Build.0 = Release|Any CPU
-		{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650}.Release|Any CPU.Build.0 = Release|Any CPU
 		{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{E5E0BF73-95F7-4BC3-8443-2336C4FF4297}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{E5E0BF73-95F7-4BC3-8443-2336C4FF4297}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{E5E0BF73-95F7-4BC3-8443-2336C4FF4297}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{E5E0BF73-95F7-4BC3-8443-2336C4FF4297}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -1519,9 +1513,8 @@ Global
 		{BD9539EB-AA5E-4E67-AC7F-97D7CBC4D0C9} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{58AD1B2C-6FFC-47CB-838A-54D0CA2BF0C8} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{8A29449D-411E-49E4-B99E-E8428076BB21} = {55A62CFA-1155-46F1-ADF3-BEEE51B58AB5}
-		{4C1B26EE-465B-4B30-9E50-0285EF7AB035} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
-		{F836BDB1-4EC7-4F4C-B2E9-BCD721C9E650} = {3E5FE3DB-45F7-4D83-9097-8F05D3B3AEC6}
 		{8BC50AFF-1EBF-4E9A-AEBB-04F387AA800F} = {FD0FAF5F-1DED-485C-99FA-84B97F3A8EEC}
+		{E5E0BF73-95F7-4BC3-8443-2336C4FF4297} = {8977A560-45C2-4EC2-A849-97335B382C74}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {604E6B91-7BC0-4126-AE07-D4D2FEFC3D29}

docs/compilers/CSharp/Compiler Breaking Changes - DotNet 7.md

@@ -1,5 +1,67 @@
 # This document lists known breaking changes in Roslyn after .NET 6 all the way to .NET 7.
 
+## Ref safety errors do not affect conversion from lambda expression to delegate
+
+***Introduced in Visual Studio 2022 version 17.5***
+
+Ref safety errors reported in a lambda body no longer affect whether the lambda expression is convertible to a delegate type. This change can affect overload resolution.
+
+In the example below, the call to `M(x => ...)` is ambiguous with Visual Studio 17.5 because both `M(D1)` and `M(D2)` are now considered applicable, even though the call to `F(ref x, ref y)` within the lambda body will result in a ref safety with `M(D1)` (see the examples in `d1` and `d2` for comparison). Previously, the call bound unambiguously to `M(D2)` because the `M(D1)` overload was considered not applicable.
+```csharp
+using System;
+
+ref struct R { }
+
+delegate R D1(R r);
+delegate object D2(object o);
+
+class Program
+{
+    static void M(D1 d1) { }
+    static void M(D2 d2) { }
+
+    static void F(ref R x, ref Span<int> y) { }
+    static void F(ref object x, ref Span<int> y) { }
+
+    static void Main()
+    {
+        // error CS0121: ambiguous between: 'M(D1)' and 'M(D2)'
+        M(x =>
+            {
+                Span<int> y = stackalloc int[1];
+                F(ref x, ref y);
+                return x;
+            });
+
+        D1 d1 = x1 =>
+            {
+                Span<int> y1 = stackalloc int[1];
+                F(ref x1, ref y1); // error CS8352: 'y2' may expose referenced variables
+                return x1;
+            };
+
+        D2 d2 = x2 =>
+            {
+                Span<int> y2 = stackalloc int[1];
+                F(ref x2, ref y2); // ok: F(ref object x, ref Span<int> y)
+                return x2;
+            };
+    }
+}
+```
+
+To workaround the overload resolution changes, use explicit types for the lambda parameters or delegate.
+
+```csharp
+        // ok: M(D2)
+        M((object x) =>
+            {
+                Span<int> y = stackalloc int[1];
+                F(ref x, ref y); // ok: F(ref object x, ref Span<int> y)
+                return x;
+            });
+```
+
 ## Raw string interpolations at start of line.
 
 ***Introduced in Visual Studio 2022 version 17.5***

docs/features/incremental-generators.md

@@ -206,18 +206,14 @@ transformations together:
 Consider the following simple example:
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
-
-    // apply a 1-to-1 transform on each text, which represents extracting the path
-    IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // transform each extracted path into something else
-    IncrementalValuesProvider<string> prefixTransform = transformed.Select(static (path, _) => "prefix_" + path);
+// apply a 1-to-1 transform on each text, which represents extracting the path
+IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
 
-});
+// transform each extracted path into something else
+IncrementalValuesProvider<string> prefixTransform = transformed.Select(static (path, _) => "prefix_" + path);
 ```
 
 Note how `transformed` and `prefixTransform` are themselves an
@@ -369,17 +365,14 @@ distinct item for generation, effectively splitting a single additional file
 into multiple sub-items.
 
 ``` csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // extract each element from each additional file
-    IncrementalValuesProvider<MyElementType> elements = additionalTexts.SelectMany(static (text, _) => /*transform text into an array of MyElementType*/);
+// extract each element from each additional file
+IncrementalValuesProvider<MyElementType> elements = additionalTexts.SelectMany(static (text, _) => /*transform text into an array of MyElementType*/);
 
-    // now the generator can consider the union of elements in all additional texts, without needing to consider multiple files
-    IncrementalValuesProvider<string> transformed = elements.Select(static (element, _) => /*transform the individual element*/);
-}
+// now the generator can consider the union of elements in all additional texts, without needing to consider multiple files
+IncrementalValuesProvider<string> transformed = elements.Select(static (element, _) => /*transform the individual element*/);
 ```
 
 ### Where
@@ -422,14 +415,11 @@ interested in. For example, the generator will likely want to filter additional
 texts on file extensions:
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // filter additional texts by extension
-    IncrementalValuesProvider<string> xmlFiles = additionalTexts.Where(static (text, _) => text.Path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase));
-}
+// filter additional texts by extension
+IncrementalValuesProvider<string> xmlFiles = additionalTexts.Where(static (text, _) => text.Path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase));
 ```
 
 ### Collect
@@ -464,18 +454,14 @@ IncrementalValuesProvider<TSource>                IncrementalValueProvider<Immut
 ```
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // collect the additional texts into a single item
-    IncrementalValueProvider<AdditionalText[]> collected = context.AdditionalTexts.Collect();
-
-    // perform a transformation where you can access all texts at once
-    var transform = collected.Select(static (texts, _) => /* ... */);
-}
+// collect the additional texts into a single item
+IncrementalValueProvider<AdditionalText[]> collected = additionalTexts.Collect();
 
+// perform a transformation where you can access all texts at once
+var transform = collected.Select(static (texts, _) => /* ... */);
 ```
 
 ### Multi-path pipelines
@@ -520,18 +506,15 @@ Those transforms can then be used as the inputs to new single path transforms, i
 For example:
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
 
-    // apply a 1-to-1 transform on each text, extracting the path
-    IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
+// apply a 1-to-1 transform on each text, extracting the path
+IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
 
-    // split the processing into two paths of derived data
-    IncrementalValuesProvider<string> nameTransform = transformed.Select(static (path, _) => "prefix_" + path);
-    IncrementalValuesProvider<string> extensionTransform = transformed.Select(static (path, _) => Path.ChangeExtension(path, ".new"));
-}
+// split the processing into two paths of derived data
+IncrementalValuesProvider<string> nameTransform = transformed.Select(static (path, _) => "prefix_" + path);
+IncrementalValuesProvider<string> extensionTransform = transformed.Select(static (path, _) => Path.ChangeExtension(path, ".new"));
 ```
 
 `nameTransform` and `extensionTransform` produce different values for the same
@@ -671,23 +654,19 @@ With the above transformations the generator author can now take one or more
 inputs and combine them into a single source of data. For example:
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
-
-    // combine each additional text with the parse options
-    IncrementalValuesProvider<(AdditionalText, ParseOptions)> combined = context.AdditionalTextsProvider.Combine(context.ParseOptionsProvider);
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // perform a transform on each text, with access to the options
-    var transformed = combined.Select(static (pair, _) => 
-    {
-        AdditionalText text = pair.Left;
-        ParseOptions parseOptions = pair.Right;
+// combine each additional text with the parse options
+IncrementalValuesProvider<(AdditionalText, ParseOptions)> combined = initContext.AdditionalTextsProvider.Combine(initContext.ParseOptionsProvider);
 
-        // do the actual transform ...
-    });
-}
+// perform a transform on each text, with access to the options
+var transformed = combined.Select(static (pair, _) => 
+{
+    AdditionalText text = pair.Left;
+    ParseOptions parseOptions = pair.Right;
+    // do the actual transform ...
+});
 ```
 
 If either of the inputs to a combine change, then subsequent transformation will
@@ -751,12 +730,9 @@ public class Class3 {}
 As an author I can make an input node that extracts the return type information 
 
 ```csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // create a syntax provider that extracts the return type kind of method symbols
-    var returnKinds = context.SyntaxProvider.CreateSyntaxProvider(static (n, _) => n is MethodDeclarationSyntax,
+// create a syntax provider that extracts the return type kind of method symbols
+    var returnKinds = initContext.SyntaxProvider.CreateSyntaxProvider(static (n, _) => n is MethodDeclarationSyntax,
                                                                   static (n, _) => ((IMethodSymbol)n.SemanticModel.GetDeclaredSymbol(n.Node)).ReturnType.Kind);
-}
 ```
 
 Initially the `predicate` will run for all syntax nodes, and select the two
@@ -856,21 +832,19 @@ For example, a generator can extract out the set of paths for the additional
 files and create a method that prints them out:
 
 ``` csharp
-initContext.RegisterExecutionPipeline(static context =>
-{
-    // get the additional text provider
-    IncrementalValuesProvider<AdditionalText> additionalTexts = context.AdditionalTextsProvider;
+// get the additional text provider
+IncrementalValuesProvider<AdditionalText> additionalTexts = initContext.AdditionalTextsProvider;
 
-    // apply a 1-to-1 transform on each text, extracting the path
-    IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
+// apply a 1-to-1 transform on each text, extracting the path
+IncrementalValuesProvider<string> transformed = additionalTexts.Select(static (text, _) => text.Path);
 
-    // collect the paths into a batch
-    IncrementalValueProvider<ImmutableArray<string>> collected = transformed.Collect();
-    
-    // take the file paths from the above batch and make some user visible syntax
-    initContext.RegisterSourceOutput(collected, static (sourceProductionContext, filePaths) =>
-    {
-        sourceProductionContext.AddSource("additionalFiles.cs", @"
+// collect the paths into a batch
+IncrementalValueProvider<ImmutableArray<string>> collected = transformed.Collect();
+
+// take the file paths from the above batch and make some user visible syntax
+initContext.RegisterSourceOutput(collected, static (sourceProductionContext, filePaths) =>
+{
+    sourceProductionContext.AddSource("additionalFiles.cs", @"
 namespace Generated
 {
     public class AdditionalTextList
@@ -881,8 +855,7 @@ namespace Generated
         }
     }
 }");
-    });
-}
+});
 ```
 
 **RegisterImplementationSourceOutput**: