Code fix to add unsafe option to C# project

src/EditorFeatures/CSharpTest/Diagnostics/UpdateProjectToAllowUnsafe/UpdateProjectToAllowUnsafeTests.cs

@@ -0,0 +1,110 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.UpdateProjectToAllowUnsafe;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.UpdateProjectToAllowUnsafe
+{
+    [Trait(Traits.Feature, Traits.Features.CodeActionsUpdateProjectToAllowUnsafe)]
+    public class UpdateProjectToAllowUnsafeTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+    {
+        internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
+            => (null, new CSharpUpdateProjectToAllowUnsafeCodeFixProvider());
+
+        private async Task TestAllowUnsafeEnabledIfDisabledAsync(string initialMarkup)
+        {
+            var parameters = new TestParameters();
+            using (var workspace = CreateWorkspaceFromOptions(initialMarkup, parameters))
+            {
+                var actions = await GetCodeActionsAsync(workspace, parameters);
+                var operations = await VerifyInputsAndGetOperationsAsync(0, actions, priority: null);
+
+                var (oldSolution, newSolution) = ApplyOperationsAndGetSolution(workspace, operations);
+                Assert.True(((CSharpCompilationOptions)newSolution.Projects.Single().CompilationOptions).AllowUnsafe);
+            }
+
+            // no action offered if unsafe was already enabled
+            await TestMissingAsync(initialMarkup, new TestParameters(compilationOptions:
+                new CSharpCompilationOptions(outputKind: default, allowUnsafe: true)));
+        }
+
+        [Fact]
+        public async Task OnUnsafeClass()
+        {
+            await TestAllowUnsafeEnabledIfDisabledAsync(
+@"
+unsafe class [|C|] // The compiler reports this on the name, not the 'unsafe' keyword.
+{
+}");
+        }
+
+        [Fact]
+        public async Task OnUnsafeMethod()
+        {
+            await TestAllowUnsafeEnabledIfDisabledAsync(
+@"
+class C
+{
+    unsafe void [|M|]()
+    {
+    }
+}");
+        }
+
+        [Fact]
+        public async Task OnUnsafeLocalFunction()
+        {
+            await TestAllowUnsafeEnabledIfDisabledAsync(
+@"
+class C
+{
+    void M()
+    {
+        unsafe void [|F|]()
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public async Task OnUnsafeBlock()
+        {
+            await TestAllowUnsafeEnabledIfDisabledAsync(
+@"
+class C
+{
+    void M()
+    {
+        [|unsafe|]
+        {
+        }
+    }
+}");
+        }
+
+        [Fact]
+        public async Task NotInsideUnsafeBlock()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    void M()
+    {
+        unsafe
+        {
+            [|int * p;|]
+        }
+    }
+}");
+        }
+    }
+}

src/EditorFeatures/CSharpTest/Diagnostics/UpgradeProject/UpgradeProjectTests.cs

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
 
+using System;
 using System.Linq;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.CodeFixes;
@@ -9,7 +10,7 @@
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Xunit;
 
-namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.Async
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.UpgradeProject
 {
     [Trait(Traits.Feature, Traits.Features.CodeActionsUpgradeProject)]
     public partial class UpgradeProjectTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
@@ -29,9 +30,7 @@ private async Task TestLanguageVersionUpgradedAsync(
                 var actions = await GetCodeActionsAsync(workspace, parameters);
                 var operations = await VerifyInputsAndGetOperationsAsync(index, actions, priority: null);
 
-                var appliedChanges = ApplyOperationsAndGetSolution(workspace, operations);
-                var oldSolution = appliedChanges.Item1;
-                var newSolution = appliedChanges.Item2;
+                var (oldSolution, newSolution) = ApplyOperationsAndGetSolution(workspace, operations);
                 Assert.All(newSolution.Projects.Where(p => p.Language == LanguageNames.CSharp),
                     p => Assert.Equal(expected, ((CSharpParseOptions)p.ParseOptions).SpecifiedLanguageVersion));
             }

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_Create.cs

@@ -59,6 +59,7 @@ public partial class TestWorkspace
         private const string AliasAttributeName = "Alias";
         private const string ProjectNameAttribute = "Name";
         private const string CheckOverflowAttributeName = "CheckOverflow";
+        private const string AllowUnsafeAttributeName = "AllowUnsafe";
 
         /// <summary>
         /// Creates a single buffer in a workspace.

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlConsumption.cs

@@ -466,6 +466,7 @@ private static CompilationOptions CreateCompilationOptions(TestWorkspace workspa
             var strongNameProvider = default(StrongNameProvider);
             var delaySign = default(bool?);
             var checkOverflow = false;
+            bool allowUnsafe = false;
 
             if (compilationOptionsElement != null)
             {
@@ -483,6 +484,12 @@ private static CompilationOptions CreateCompilationOptions(TestWorkspace workspa
                     checkOverflow = (bool)checkOverflowAttribute;
                 }
 
+                var allowUnsafeAttribute = compilationOptionsElement.Attribute(AllowUnsafeAttributeName);
+                if (allowUnsafeAttribute != null)
+                {
+                    allowUnsafe = (bool)allowUnsafeAttribute;
+                }
+
                 var reportDiagnosticAttribute = compilationOptionsElement.Attribute(ReportDiagnosticAttributeName);
                 if (reportDiagnosticAttribute != null)
                 {
@@ -529,7 +536,7 @@ private static CompilationOptions CreateCompilationOptions(TestWorkspace workspa
 
                     // VB needs Compilation.ParseOptions set (we do the same at the VS layer)
                     return language == LanguageNames.CSharp
-                       ? (CompilationOptions)new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata)
+                       ? (CompilationOptions)new CSharpCompilationOptions(OutputKind.WindowsRuntimeMetadata, allowUnsafe: allowUnsafe)
                        : new VisualBasicCompilationOptions(OutputKind.WindowsRuntimeMetadata).WithGlobalImports(globalImports).WithRootNamespace(rootNamespace)
                             .WithParseOptions((VisualBasicParseOptions)parseOptions ?? VisualBasicParseOptions.Default);
                 }
@@ -557,6 +564,11 @@ private static CompilationOptions CreateCompilationOptions(TestWorkspace workspa
                                                    .WithDelaySign(delaySign)
                                                    .WithOverflowChecks(checkOverflow);
 
+            if (language == LanguageNames.CSharp)
+            {
+                compilationOptions = ((CSharpCompilationOptions)compilationOptions).WithAllowUnsafe(allowUnsafe);
+            }
+
             if (language == LanguageNames.VisualBasic)
             {
                 // VB needs Compilation.ParseOptions set (we do the same at the VS layer)

src/EditorFeatures/TestUtilities/Workspaces/TestWorkspace_XmlCreation.cs

@@ -76,11 +76,15 @@ private static XAttribute CreateDocumentationModeAttribute(ParseOptions parseOpt
 
         private static XElement CreateCompilationOptionsElement(CompilationOptions options)
         {
-            XElement element = null;
-            if (options is Microsoft.CodeAnalysis.VisualBasic.VisualBasicCompilationOptions vbOptions)
+            var element = new XElement(CompilationOptionsElementName);
+
+            if (options is CodeAnalysis.CSharp.CSharpCompilationOptions csOptions)
+            {
+                element.SetAttributeValue(AllowUnsafeAttributeName, csOptions.AllowUnsafe);
+            }
+            else if (options is CodeAnalysis.VisualBasic.VisualBasicCompilationOptions vbOptions)
             {
-                element = new XElement(CompilationOptionsElementName,
-                    vbOptions.GlobalImports.AsEnumerable().Select(i => new XElement(GlobalImportElementName, i.Name)));
+                element.Add(vbOptions.GlobalImports.AsEnumerable().Select(i => new XElement(GlobalImportElementName, i.Name)));
 
                 if (vbOptions.RootNamespace != null)
                 {
@@ -90,7 +94,6 @@ private static XElement CreateCompilationOptionsElement(CompilationOptions optio
 
             if (options.CheckOverflow)
             {
-                element = element ?? new XElement(CompilationOptionsElementName);
                 element.SetAttributeValue(CheckOverflowAttributeName, true);
             }
 

src/Features/CSharp/Portable/CSharpFeaturesResources.resx

@@ -527,4 +527,7 @@
   <data name="Convert_to_for" xml:space="preserve">
     <value>Convert to 'for'</value>
   </data>
+  <data name="Allow_unsafe_code_in_this_project" xml:space="preserve">
+    <value>Allow unsafe code in this project</value>
+  </data>
 </root>

src/Features/CSharp/Portable/UpdateProjectToAllowUnsafe/CSharpUpdateProjectToAllowUnsafeCodeFixProvider.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft.  All Rights Reserved.  Licensed under the Apache License, Version 2.0.  See License.txt in the project root for license information.
+
+using System.Collections.Immutable;
+using System.Composition;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.UpgradeProject;
+
+namespace Microsoft.CodeAnalysis.CSharp.UpdateProjectToAllowUnsafe
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    internal class CSharpUpdateProjectToAllowUnsafeCodeFixProvider : CodeFixProvider
+    {
+        private const string CS0227 = nameof(CS0227); // error CS0227: Unsafe code may only appear if compiling with /unsafe
+
+        public override ImmutableArray<string> FixableDiagnosticIds { get; } =
+            ImmutableArray.Create(CS0227);
+
+        public override FixAllProvider GetFixAllProvider()
+        {
+            // We're OK with users having to explicitly opt in each project. Unsafe code is itself an edge case and we don't
+            // need to make it easier to convert to it on a larger scale. It's also unlikely that anyone will need this.
+            return null;
+        }
+
+        public override Task RegisterCodeFixesAsync(CodeFixContext context)
+        {
+            context.RegisterCodeFix(new ProjectOptionsChangeAction(CSharpFeaturesResources.Allow_unsafe_code_in_this_project,
+                _ => Task.FromResult(AllowUnsafeOnProject(context.Document.Project))), context.Diagnostics);
+            return Task.CompletedTask;
+        }
+
+        private static Solution AllowUnsafeOnProject(Project project)
+        {
+            var compilationOptions = (CSharpCompilationOptions)project.CompilationOptions;
+            return project.Solution.WithProjectCompilationOptions(project.Id, compilationOptions.WithAllowUnsafe(true));
+        }
+    }
+}

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.cs.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.de.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.es.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.fr.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.it.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ja.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>

src/Features/CSharp/Portable/xlf/CSharpFeaturesResources.ko.xlf

@@ -642,6 +642,11 @@
         <target state="new">Convert to 'for'</target>
         <note />
       </trans-unit>
+      <trans-unit id="Allow_unsafe_code_in_this_project">
+        <source>Allow unsafe code in this project</source>
+        <target state="new">Allow unsafe code in this project</target>
+        <note />
+      </trans-unit>
     </body>
   </file>
 </xliff>