Merge master to features/module-initializers

azure-pipelines-richnav.yml

@@ -1,11 +1,13 @@
-# Run on master CI builds
-trigger:
+trigger: none
+pr: none
+
+schedules:
+- cron: "0 0 * * *"
+  displayName: Daily midnight (UTC) RichNav indexer run
   branches:
     include:
     - master
 
-pr: none
-
 jobs:
 - job: RichCodeNav_Indexing
   pool:

eng/Version.Details.xml

@@ -7,9 +7,9 @@
       <Uri>https://github.com/dotnet/arcade</Uri>
       <Sha>9b71be0663493cd0e111b55536a2e1eeb272f54c</Sha>
     </Dependency>
-    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="3.7.0-2.20267.1">
+    <Dependency Name="Microsoft.Net.Compilers.Toolset" Version="3.7.0-4.20314.5">
       <Uri>https://github.com/dotnet/roslyn</Uri>
-      <Sha>3126e7a9753bf09a99e4c4f152b8dfef76862dc5</Sha>
+      <Sha>c2835e1b5cdb18dba1edb7991942abb68ba1b83f</Sha>
     </Dependency>
   </ToolsetDependencies>
 </Dependencies>

eng/Versions.props

@@ -23,7 +23,7 @@
     </MajorVersion>
     <MinorVersion>
     </MinorVersion>
-    <MicrosoftNetCompilersToolsetVersion>3.7.0-2.20267.1</MicrosoftNetCompilersToolsetVersion>
+    <MicrosoftNetCompilersToolsetVersion>3.7.0-4.20314.5</MicrosoftNetCompilersToolsetVersion>
   </PropertyGroup>
   <PropertyGroup>
     <!-- Versions used by several individual references below -->

eng/build.ps1

@@ -222,8 +222,6 @@ function BuildSolution() {
 
   # The warnAsError flag for MSBuild will promote all warnings to errors. This is true for warnings
   # that MSBuild output as well as ones that custom tasks output.
-  #
-  # In all cases we pass /p:TreatWarningsAsErrors=true to promote compiler warnings to errors
   $msbuildWarnAsError = if ($warnAsError) { "/warnAsError" } else { "" }
 
   # Workaround for some machines in the AzDO pool not allowing long paths (%5c is msbuild escaped backslash)
@@ -255,7 +253,7 @@ function BuildSolution() {
       /p:UseRoslynAnalyzers=$runAnalyzers `
       /p:BootstrapBuildPath=$bootstrapDir `
       /p:TestTargetFrameworks=$testTargetFrameworks `
-      /p:TreatWarningsAsErrors=true `
+      /p:TreatWarningsAsErrors=$warnAsError `
       /p:EnableNgenOptimization=$applyOptimizationData `
       /p:IbcOptimizationDataDir=$ibcDir `
       $restoreUseStaticGraphEvaluation `

eng/config/test/BannedSymbols.txt

@@ -0,0 +1 @@
+M:Moq.Mock`1.#ctor; Pass MockBehavior.Strict explicitly to the constructor for Mock<T>

eng/targets/XUnit.targets

@@ -6,6 +6,11 @@
     <PrepareForBuildDependsOn>$(PrepareForBuildDependsOn);AddDefaultTestAppConfig</PrepareForBuildDependsOn>
   </PropertyGroup>
 
+  <ItemGroup>
+    <!-- Include BannedSymbols covering all test projects -->
+    <AdditionalFiles Include="$(MSBuildThisFileDirectory)..\config\test\BannedSymbols.txt" />
+  </ItemGroup>
+
   <!-- Add a default test app.config, if the project doesn't already have one-->
   <Target Name="AddDefaultTestAppConfig">
     <PropertyGroup>

src/Analyzers/CSharp/Analyzers/MakeStructFieldsWritable/CSharpMakeStructFieldsWritableDiagnosticAnalyzer.cs

@@ -37,7 +37,7 @@ protected override void InitializeWorker(AnalysisContext context)
         private sealed class SymbolAnalyzer
         {
             private readonly INamedTypeSymbol _namedTypeSymbol;
-            private bool _hasTypeInstanceAssigment;
+            private bool _hasTypeInstanceAssignment;
 
             private SymbolAnalyzer(INamedTypeSymbol namedTypeSymbol)
                 => _namedTypeSymbol = namedTypeSymbol;
@@ -99,13 +99,13 @@ private void AnalyzeAssignment(OperationAnalysisContext context)
                 var operationAssigmnent = (IAssignmentOperation)context.Operation;
                 if (operationAssigmnent.Target is IInstanceReferenceOperation { ReferenceKind: InstanceReferenceKind.ContainingTypeInstance })
                 {
-                    Volatile.Write(ref _hasTypeInstanceAssigment, true);
+                    Volatile.Write(ref _hasTypeInstanceAssignment, true);
                 }
             }
 
             private void SymbolEndAction(SymbolAnalysisContext context)
             {
-                if (_hasTypeInstanceAssigment)
+                if (_hasTypeInstanceAssignment)
                 {
                     var diagnostic = Diagnostic.Create(
                                     s_diagnosticDescriptor,

src/Analyzers/CSharp/Tests/RemoveUnusedMembers/RemoveUnusedMembersTests.cs

@@ -5,6 +5,8 @@
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CSharp.RemoveUnusedMembers;
+using Microsoft.CodeAnalysis.CSharp.Shared.Extensions;
+using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Testing;
 using Roslyn.Test.Utilities;
@@ -356,6 +358,113 @@ class MyClass
             await VerifyCS.VerifyCodeFixAsync(code, code);
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedMembers)]
+        public async Task EntryPointMethodNotFlagged_06()
+        {
+            var code = @"
+return 0;
+";
+
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = code,
+                ExpectedDiagnostics =
+                {
+                    // error CS8805: Program using top-level statements must be an executable.
+                    DiagnosticResult.CompilerError("CS8805"),
+                },
+                LanguageVersion = LanguageVersionExtensions.CSharp9,
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedMembers)]
+        public async Task EntryPointMethodNotFlagged_07()
+        {
+            var code = @"
+return 0;
+";
+
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources = { code, code },
+                },
+                FixedState =
+                {
+                    Sources = { code, code },
+                },
+                ExpectedDiagnostics =
+                {
+                    // error CS8805: Program using top-level statements must be an executable.
+                    DiagnosticResult.CompilerError("CS8805"),
+                    // /0/Test1.cs(2,1): error CS8802: Only one compilation unit can have top-level statements.
+                    DiagnosticResult.CompilerError("CS8802").WithSpan("/0/Test1.cs", 2, 1, 2, 7),
+                },
+                LanguageVersion = LanguageVersionExtensions.CSharp9,
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedMembers)]
+        public async Task EntryPointMethodNotFlagged_08()
+        {
+            var code = @"
+return 0;
+";
+
+            await new VerifyCS.Test
+            {
+                TestCode = code,
+                FixedCode = code,
+                SolutionTransforms =
+                {
+                    (solution, projectId) =>
+                    {
+                        var project = solution.GetRequiredProject(projectId);
+                        var compilationOptions = project.CompilationOptions;
+                        return solution.WithProjectCompilationOptions(projectId, compilationOptions.WithOutputKind(OutputKind.ConsoleApplication));
+                    },
+                },
+                LanguageVersion = LanguageVersionExtensions.CSharp9,
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedMembers)]
+        public async Task EntryPointMethodNotFlagged_09()
+        {
+            var code = @"
+return 0;
+";
+
+            await new VerifyCS.Test
+            {
+                TestState =
+                {
+                    Sources = { code, code },
+                },
+                FixedState =
+                {
+                    Sources = { code, code },
+                },
+                ExpectedDiagnostics =
+                {
+                    // /0/Test1.cs(2,1): error CS8802: Only one compilation unit can have top-level statements.
+                    DiagnosticResult.CompilerError("CS8802").WithSpan("/0/Test1.cs", 2, 1, 2, 7),
+                },
+                SolutionTransforms =
+                {
+                    (solution, projectId) =>
+                    {
+                        var project = solution.GetRequiredProject(projectId);
+                        var compilationOptions = project.CompilationOptions;
+                        return solution.WithProjectCompilationOptions(projectId, compilationOptions.WithOutputKind(OutputKind.ConsoleApplication));
+                    },
+                },
+                LanguageVersion = LanguageVersionExtensions.CSharp9,
+            }.RunAsync();
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsRemoveUnusedMembers)]
         public async Task FieldIsUnused_ReadOnly()
         {

src/Analyzers/CSharp/Tests/ValidateFormatString/ValidateFormatStringTests.cs

@@ -133,6 +133,18 @@ static void Main(string[] args)
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
+        public async Task LiteralArray()
+        {
+            await TestDiagnosticMissingAsync(@" class Program
+{
+    static void Main(string[] args)
+    {
+        string.Format(""This {0[||]} {1} {2} {3} works"", new [] {""test1"", ""test2"", ""test3"", ""test4""}); 
+    }     
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)]
         public async Task StringArrayOutOfBounds_NoDiagnostic()
         {

src/Analyzers/Core/Analyzers/RemoveUnusedMembers/AbstractRemoveUnusedMembersDiagnosticAnalyzer.cs

@@ -382,9 +382,16 @@ private void OnSymbolEnd(SymbolAnalysisContext symbolEndContext, bool hasUnsuppo
                 ArrayBuilder<string> debuggerDisplayAttributeArguments = null;
                 try
                 {
+                    var entryPoint = symbolEndContext.Compilation.GetEntryPoint(symbolEndContext.CancellationToken);
+
                     var namedType = (INamedTypeSymbol)symbolEndContext.Symbol;
                     foreach (var member in namedType.GetMembers())
                     {
+                        if (SymbolEqualityComparer.Default.Equals(entryPoint, member))
+                        {
+                            continue;
+                        }
+
                         // Check if the underlying member is neither read nor a readable reference to the member is taken.
                         // If so, we flag the member as either unused (never written) or unread (written but not read).
                         if (TryRemove(member, out var valueUsageInfo) &&
@@ -689,7 +696,7 @@ private bool IsCandidateSymbol(ISymbol memberSymbol)
             }
 
             private bool IsEntryPoint(IMethodSymbol methodSymbol)
-                => methodSymbol.Name == WellKnownMemberNames.EntryPointMethodName &&
+                => (methodSymbol.Name == WellKnownMemberNames.EntryPointMethodName || methodSymbol.Name == "$Main") &&
                    methodSymbol.IsStatic &&
                    (methodSymbol.ReturnsVoid ||
                     methodSymbol.ReturnType.SpecialType == SpecialType.System_Int32 ||

src/Analyzers/Core/Analyzers/ValidateFormatString/AbstractValidateFormatStringDiagnosticAnalyzer.cs

@@ -204,7 +204,7 @@ private bool ArgsIsArrayOfReferenceTypes(
             }
 
             var expression = syntaxFacts.GetExpressionOfArgument(argsArgument);
-            return semanticModel.GetTypeInfo(expression).Type;
+            return semanticModel.GetTypeInfo(expression).ConvertedType;
         }
 
         protected SyntaxNode? TryGetArgument(

src/Analyzers/VisualBasic/Tests/ValidateFormatString/ValidateFormatStringTests.vb

@@ -27,11 +27,33 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.ValidateFormatStri
         End Function
 
         <Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)>
-        Public Async Function ParamsObjectArray() As Task
+        Public Async Function ObjectArray() As Task
             Await TestDiagnosticMissingAsync("
 Class C
      Sub Main 
-        string.Format(""This {0} {1} {[||]2} works"", New Object  { ""test"", ""test2"", ""test3"" })
+        string.Format(""This {0} {1} {[||]2} works"", New Object() { ""test"", ""test2"", ""test3"" })
+    End Sub
+End Class")
+        End Function
+
+        <WorkItem(42764, "https://github.com/dotnet/roslyn/issues/42764")>
+        <Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)>
+        Public Async Function LiteralArray() As Task
+            Await TestDiagnosticMissingAsync("
+Class C
+     Sub Main 
+        string.Format(""This {0[||]} {1} {2} {3} works"", { ""test"", ""test2"", ""test3"", ""test4"" })
+    End Sub
+End Class")
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.ValidateFormatString)>
+        Public Async Function StringArray() As Task
+            Await TestDiagnosticMissingAsync("
+Class C
+     Sub Main 
+        Dim strings() = {""test"", ""test2""}
+        String.Format(""This {0} {[||]1} works"", strings)
     End Sub
 End Class")
         End Function

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

@@ -515,7 +515,7 @@ internal bool CheckValueKind(SyntaxNode node, BoundExpression expr, BindValueKin
 
                 case BoundKind.IndexOrRangePatternIndexerAccess:
                     var patternIndexer = (BoundIndexOrRangePatternIndexerAccess)expr;
-                    // If we got here this should be a pttern indexer taking a Range,
+                    // If we got here this should be a pattern indexer taking a Range,
                     // meaning that the pattern symbol must be a method (either Slice or Substring)
                     return CheckMethodReturnValueKind(
                         (MethodSymbol)patternIndexer.PatternSymbol,
@@ -2569,6 +2569,11 @@ internal static uint GetValEscape(BoundExpression expr, uint scopeOfTheContainin
                     // only possible in error cases (if possible at all)
                     return scopeOfTheContainingExpression;
 
+                case BoundKind.ConvertedSwitchExpression:
+                case BoundKind.UnconvertedSwitchExpression:
+                    var switchExpr = (BoundSwitchExpression)expr;
+                    return GetValEscape(switchExpr.SwitchArms.SelectAsArray(a => a.Value), scopeOfTheContainingExpression);
+
                 default:
                     // in error situations some unexpected nodes could make here
                     // returning "scopeOfTheContainingExpression" seems safer than throwing.

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

@@ -226,8 +226,9 @@ private BoundExpression BindObjectCreationExpression(BoundUnconvertedObjectCreat
         private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression source, TypeSymbol destination, Conversion? conversionIfTargetTyped, DiagnosticBag diagnostics, bool hasErrors = false)
         {
             bool targetTyped = conversionIfTargetTyped != null;
+            Conversion conversion = conversionIfTargetTyped ?? Conversion.Identity;
             Debug.Assert(targetTyped || destination.IsErrorType() || destination.Equals(source.Type, TypeCompareKind.ConsiderEverything));
-            ImmutableArray<Conversion> underlyingConversions = conversionIfTargetTyped.GetValueOrDefault().UnderlyingConversions;
+            ImmutableArray<Conversion> underlyingConversions = conversion.UnderlyingConversions;
             var builder = ArrayBuilder<BoundSwitchExpressionArm>.GetInstance(source.SwitchArms.Length);
             for (int i = 0, n = source.SwitchArms.Length; i < n; i++)
             {
@@ -244,7 +245,7 @@ private BoundExpression ConvertSwitchExpression(BoundUnconvertedSwitchExpression
 
             var newSwitchArms = builder.ToImmutableAndFree();
             return new BoundConvertedSwitchExpression(
-                source.Syntax, source.Type, targetTyped, source.Expression, newSwitchArms, source.DecisionDag,
+                source.Syntax, source.Type, targetTyped, conversion, source.Expression, newSwitchArms, source.DecisionDag,
                 source.DefaultLabel, source.ReportedNotExhaustive, destination, hasErrors || source.HasErrors);
         }
 
@@ -912,7 +913,7 @@ internal bool MethodIsCompatibleWithDelegateOrFunctionPointer(BoundExpression? r
                 //  * Every value parameter (non-ref or similar) from the delegate type has an implicit conversion to the corresponding
                 //    target parameter
                 //  * Every ref or similar parameter has an identity conversion to the corresponding target parameter
-                // However, the delegate compatiblity requirements are stricter:
+                // However, the delegate compatibility requirements are stricter:
                 //  * Every value parameter (non-ref or similar) from the delegate type has an implicit _reference_ conversion to the
                 //    corresponding target parameter.
                 //  * Every ref or similar parameter has an identity conversion to the corresponding target parameter