Merge 'Top-level statements' feature into master

docs/features/TopLevelStatements.md

@@ -0,0 +1,21 @@
+Top-level statements
+=========================
+
+Allow a sequence of *statements* to occur right before the *namespace_member_declaration*s of a *compilation_unit* (i.e. source file).
+
+The semantics are that if such a sequence of *statements* is present, the following type declaration, modulo the actual type name and the method name, would be emitted:
+
+``` c#
+static class Program
+{
+    static async Task Main()
+    {
+        // statements
+    }
+}
+```
+
+Proposal: https://github.com/dotnet/csharplang/blob/master/proposals/top-level-statements.md
+Open issues and TODOs are tracked at https://github.com/dotnet/roslyn/issues/41704.
+Test plan: https://github.com/dotnet/roslyn/issues/43563.
+See also https://github.com/dotnet/csharplang/issues/3117.

src/Analyzers/CSharp/CodeFixes/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionCodeFixProvider.cs

@@ -81,7 +81,7 @@ protected override async Task FixAllAsync(
                     declaratorToRemoveTypeOpt = semanticModel.GetDeclaredSymbol(declaratorToRemoveNodeOpt).GetSymbolType();
                 }
 
-                var switchStatement = (SwitchStatementSyntax)switchLocation.FindNode(cancellationToken);
+                var switchStatement = (SwitchStatementSyntax)switchLocation.FindNode(getInnermostNodeForTie: true, cancellationToken);
                 var switchExpression = Rewriter.Rewrite(
                     switchStatement, declaratorToRemoveTypeOpt, nodeToGenerate,
                     shouldMoveNextStatementToSwitchExpression: shouldRemoveNextStatement,
@@ -97,9 +97,9 @@ protected override async Task FixAllAsync(
                 if (shouldRemoveNextStatement)
                 {
                     // Already morphed into the top-level switch expression.
-                    var nextStatement = switchStatement.GetNextStatement();
+                    SyntaxNode nextStatement = switchStatement.GetNextStatement();
                     Debug.Assert(nextStatement.IsKind(SyntaxKind.ThrowStatement, SyntaxKind.ReturnStatement));
-                    editor.RemoveNode(nextStatement);
+                    editor.RemoveNode(nextStatement.IsParentKind(SyntaxKind.GlobalStatement) ? nextStatement.Parent : nextStatement);
                 }
             }
         }

src/Analyzers/CSharp/Tests/ConvertSwitchStatementToExpression/ConvertSwitchStatementToExpressionTests.cs

@@ -1890,5 +1890,86 @@ static void GetRef(int[] mem, int addr, int mode)
     }
 }");
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        public async Task TopLevelStatement()
+        {
+            var source = @"
+int i = 0;
+[|switch|] (i)
+{
+    case 1:
+        return 4;
+    default:
+        return 7;
+}";
+
+            var fixedSource = @"
+int i = 0;
+return i switch
+{
+    1 => 4,
+    _ => 7,
+};
+";
+
+            var test = new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = fixedSource,
+                LanguageVersion = LanguageVersion.Preview,
+            };
+
+            test.ExpectedDiagnostics.Add(
+                // error CS9004: Program using top-level statements must be an executable.
+                DiagnosticResult.CompilerError("CS9004"));
+
+            await test.RunAsync();
+        }
+
+        [WorkItem(44449, "https://github.com/dotnet/roslyn/issues/44449")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsConvertSwitchStatementToExpression)]
+        public async Task TopLevelStatement_FollowedWithThrow()
+        {
+            // We should be rewriting the declaration for 'j' to get 'var j = i switch ...'
+            var source = @"
+int i = 0;
+int j;
+[|switch|] (i)
+{
+    case 1:
+        j = 4;
+        break;
+    case 2:
+        j = 5;
+        break;
+}
+throw null;
+";
+
+            var fixedSource = @"
+int i = 0;
+int j;
+j = i switch
+{
+    1 => 4,
+    2 => 5,
+    _ => throw null,
+};
+";
+
+            var test = new VerifyCS.Test
+            {
+                TestCode = source,
+                FixedCode = fixedSource,
+                LanguageVersion = LanguageVersion.Preview,
+            };
+
+            test.ExpectedDiagnostics.Add(
+                // error CS9004: Program using top-level statements must be an executable.
+                DiagnosticResult.CompilerError("CS9004"));
+
+            await test.RunAsync();
+        }
     }
 }

src/Analyzers/CSharp/Tests/InlineDeclaration/CSharpInlineDeclarationTests.cs

@@ -6,6 +6,7 @@
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.InlineDeclaration;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.UseImplicitType;
@@ -2280,5 +2281,16 @@ void M(out C c2)
     }
 }");
         }
+
+        [WorkItem(44429, "https://github.com/dotnet/roslyn/issues/44429")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInlineDeclaration)]
+        public async Task TopLevelStatement()
+        {
+            await TestMissingAsync(@"
+[|int|] i;
+if (int.TryParse(v, out i))
+{
+}", new TestParameters(TestOptions.Regular));
+        }
     }
 }

src/Analyzers/CSharp/Tests/RemoveUnnecessaryCast/RemoveUnnecessaryCastTests.cs

@@ -142,7 +142,8 @@ static void Main()
         }
 
         [WorkItem(545138, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545138")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        [WorkItem(44422, "https://github.com/dotnet/roslyn/issues/44422")]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/44422"), Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
         public async Task DontRemoveTypeParameterCastToObject()
         {
             var source =
@@ -173,7 +174,8 @@ await VerifyCS.VerifyCodeFixAsync(
         }
 
         [WorkItem(545139, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545139")]
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
+        [WorkItem(44422, "https://github.com/dotnet/roslyn/issues/44422")]
+        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/44422"), Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnnecessaryCast)]
         public async Task DontRemoveCastInIsTest()
         {
             var source =

src/Analyzers/CSharp/Tests/UseThrowExpression/UseThrowExpressionTests.cs

@@ -5,6 +5,8 @@
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
 using Microsoft.CodeAnalysis.CSharp.UseThrowExpression;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics;
@@ -541,5 +543,24 @@ public A(T? t)
     }
 }");
         }
+
+        [WorkItem(44454, "https://github.com/dotnet/roslyn/issues/44454")]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsUseThrowExpression)]
+        public async Task TopLevelStatement()
+        {
+            await TestAsync(
+@"using System;
+string s = null;
+string x = null;
+if (s == null) [|throw|] new ArgumentNullException();
+x = s;
+",
+@"using System;
+string s = null;
+string x = null;
+
+x = s ?? throw new ArgumentNullException();
+", TestOptions.Regular.WithLanguageVersion(LanguageVersionExtensions.CSharp9));
+        }
     }
 }

src/Analyzers/Core/Analyzers/UseThrowExpression/AbstractUseThrowExpressionDiagnosticAnalyzer.cs

@@ -102,7 +102,7 @@ private void AnalyzeOperation(OperationAnalysisContext context, INamedTypeSymbol
                 return;
             }
 
-            if (!(semanticModel.GetOperation(ifOperation.Syntax.Parent, cancellationToken) is IBlockOperation containingBlock))
+            if (!(ifOperation.Parent is IBlockOperation containingBlock))
             {
                 return;
             }

src/Compilers/CSharp/CSharpAnalyzerDriver/CSharpDeclarationComputer.cs

@@ -23,20 +23,21 @@ public static void ComputeDeclarationsInSpan(
             ArrayBuilder<DeclarationInfo> builder,
             CancellationToken cancellationToken)
         {
-            ComputeDeclarations(model, model.SyntaxTree.GetRoot(cancellationToken),
+            ComputeDeclarations(model, associatedSymbol: null, model.SyntaxTree.GetRoot(cancellationToken),
                 (node, level) => !node.Span.OverlapsWith(span) || InvalidLevel(level),
                 getSymbol, builder, null, cancellationToken);
         }
 
         public static void ComputeDeclarationsInNode(
             SemanticModel model,
+            ISymbol associatedSymbol,
             SyntaxNode node,
             bool getSymbol,
             ArrayBuilder<DeclarationInfo> builder,
             CancellationToken cancellationToken,
             int? levelsToCompute = null)
         {
-            ComputeDeclarations(model, node, (n, level) => InvalidLevel(level), getSymbol, builder, levelsToCompute, cancellationToken);
+            ComputeDeclarations(model, associatedSymbol, node, (n, level) => InvalidLevel(level), getSymbol, builder, levelsToCompute, cancellationToken);
         }
 
         private static bool InvalidLevel(int? level)
@@ -51,6 +52,7 @@ private static bool InvalidLevel(int? level)
 
         private static void ComputeDeclarations(
             SemanticModel model,
+            ISymbol associatedSymbol,
             SyntaxNode node,
             Func<SyntaxNode, int?, bool> shouldSkip,
             bool getSymbol,
@@ -74,7 +76,7 @@ private static void ComputeDeclarations(
                         var ns = (NamespaceDeclarationSyntax)node;
                         foreach (var decl in ns.Members)
                         {
-                            ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                            ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                         }
 
                         var declInfo = GetDeclarationInfo(model, node, getSymbol, cancellationToken);
@@ -100,7 +102,7 @@ private static void ComputeDeclarations(
                         var t = (TypeDeclarationSyntax)node;
                         foreach (var decl in t.Members)
                         {
-                            ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                            ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                         }
 
                         var attributes = GetAttributes(t.AttributeLists).Concat(GetTypeParameterListAttributes(t.TypeParameterList));
@@ -113,7 +115,7 @@ private static void ComputeDeclarations(
                         var t = (EnumDeclarationSyntax)node;
                         foreach (var decl in t.Members)
                         {
-                            ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                            ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                         }
 
                         var attributes = GetAttributes(t.AttributeLists);
@@ -147,7 +149,7 @@ private static void ComputeDeclarations(
                         {
                             foreach (var decl in t.AccessorList.Accessors)
                             {
-                                ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                                ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                             }
                         }
                         var attributes = GetAttributes(t.AttributeLists);
@@ -187,13 +189,13 @@ private static void ComputeDeclarations(
                         {
                             foreach (var decl in t.AccessorList.Accessors)
                             {
-                                ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                                ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                             }
                         }
 
                         if (t.ExpressionBody != null)
                         {
-                            ComputeDeclarations(model, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
+                            ComputeDeclarations(model, associatedSymbol: null, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
                         }
 
                         var attributes = GetAttributes(t.AttributeLists);
@@ -209,13 +211,13 @@ private static void ComputeDeclarations(
                         {
                             foreach (var decl in t.AccessorList.Accessors)
                             {
-                                ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                                ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
                             }
                         }
 
                         if (t.ExpressionBody != null)
                         {
-                            ComputeDeclarations(model, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
+                            ComputeDeclarations(model, associatedSymbol: null, t.ExpressionBody, shouldSkip, getSymbol, builder, levelsToCompute, cancellationToken);
                         }
 
                         var codeBlocks = GetParameterListInitializersAndAttributes(t.ParameterList);
@@ -277,16 +279,25 @@ private static void ComputeDeclarations(
                 case SyntaxKind.CompilationUnit:
                     {
                         var t = (CompilationUnitSyntax)node;
-                        foreach (var decl in t.Members)
+
+                        if (associatedSymbol is IMethodSymbol)
                         {
-                            ComputeDeclarations(model, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                            builder.Add(GetDeclarationInfo(model, node, getSymbol, new[] { t }, cancellationToken));
                         }
-
-                        if (t.AttributeLists.Any())
+                        else
                         {
-                            var attributes = GetAttributes(t.AttributeLists);
-                            builder.Add(GetDeclarationInfo(model, node, getSymbol, attributes, cancellationToken));
+                            foreach (var decl in t.Members)
+                            {
+                                ComputeDeclarations(model, associatedSymbol: null, decl, shouldSkip, getSymbol, builder, newLevel, cancellationToken);
+                            }
+
+                            if (t.AttributeLists.Any())
+                            {
+                                var attributes = GetAttributes(t.AttributeLists);
+                                builder.Add(GetDeclarationInfo(model, node, getSymbol: false, attributes, cancellationToken));
+                            }
                         }
+
                         return;
                     }
 

src/Compilers/CSharp/Portable/Binder/Binder.cs

@@ -387,7 +387,7 @@ internal virtual QuickAttributeChecker QuickAttributeChecker
             }
         }
 
-        internal virtual Imports GetImports(ConsList<TypeSymbol> basesBeingResolved)
+        internal virtual Imports GetImports(ConsList<TypeSymbol>? basesBeingResolved)
         {
             RoslynDebug.Assert(Next is object);
             return Next.GetImports(basesBeingResolved);