Code fix to add unsafe option to C# project

src/EditorFeatures/CSharpTest/Diagnostics/UnsafeProject/UnsafeProjectTests.cs

@@ -0,0 +1,111 @@
+// 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.Linq;
+using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.UnsafeProject;
+using Microsoft.CodeAnalysis.Diagnostics;
+using Microsoft.CodeAnalysis.Test.Utilities;
+using Xunit;
+
+namespace Microsoft.CodeAnalysis.Editor.CSharp.UnitTests.Diagnostics.UnsafeProject
+{
+    [Trait(Traits.Feature, Traits.Features.CodeActionsUnsafeProject)]
+    public class UnsafeProjectTests : AbstractCSharpDiagnosticProviderBasedUserDiagnosticTest
+    {
+        internal override (DiagnosticAnalyzer, CodeFixProvider) CreateDiagnosticProviderAndFixer(Workspace workspace)
+            => (null, new CSharpUnsafeProjectCodeFixProvider());
+
+        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 appliedChanges = ApplyOperationsAndGetSolution(workspace, operations);
+                var oldSolution = appliedChanges.Item1;
+                var newSolution = appliedChanges.Item2;
+                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 [|Function|]()
+        {
+        }
+    }
+}");
+        }
+
+        [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/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

@@ -524,4 +524,7 @@
   <data name="Convert_for_to_foreach" xml:space="preserve">
     <value>Convert 'for' to 'foreach'</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/UnsafeProject/CSharpUnsafeProjectCodeFixProvider.cs

@@ -0,0 +1,44 @@
+// 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.UnsafeProject
+{
+    [ExportCodeFixProvider(LanguageNames.CSharp), Shared]
+    internal class CSharpUnsafeProjectCodeFixProvider : 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()
+        {
+            // Fix all could be implemented, but doesn't seem as important because for this to be useful,
+            // the user would have to have erroneous unsafe blocks in several projects, which sounds really unlikely.
+            // And after all, unsafe code itself is and should be an edge case - do we want to make it easier
+            // to convert to it on a larger scale?
+            // If we do this, we should create a custom FixAllProvider that only supports FixAllScope.Solution
+            // since Document and Project don't really make sense - the action would always be the same as for fix one
+            // and having these extra options would only be confusing.
+            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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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.pl.xlf

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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.pt-BR.xlf

@@ -637,6 +637,11 @@
         <target state="new">Convert 'for' to 'foreach'</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>