Use !! in AddParameterCheck refactoring

src/EditorFeatures/CSharpTest/InitializeParameter/AddParameterCheckTests.cs

@@ -30,6 +30,33 @@ public async Task TestEmptyFile()
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
         public async Task TestSimpleReferenceType()
+        {
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+using System;
+
+class C
+{
+    public C([||]string s)
+    {
+    }
+}",
+                FixedCode = @"
+using System;
+
+class C
+{
+    public C(string s!!)
+    {
+    }
+}"
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestSimpleReferenceType_CSharp8()
         {
             await VerifyCS.VerifyRefactoringAsync(
 @"
@@ -210,6 +237,28 @@ public async Task TestNotOnPartialMethodDefinition1()
             var code = @"
 using System;
 
+partial class C
+{
+    partial void M([||]string s);
+
+    partial void M(string s)
+    {
+    }
+}";
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = code,
+                FixedCode = code
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestNotOnPartialMethodDefinition1_CSharp8()
+        {
+            var code = @"
+using System;
+
 partial class C
 {
     partial void M([||]string s);
@@ -249,6 +298,28 @@ public async Task TestNotOnPartialMethodDefinition2()
             var code = @"
 using System;
 
+partial class C
+{
+    partial void M(string s)
+    {
+    }
+
+    partial void M([||]string s);
+}";
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = code,
+                FixedCode = code
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestNotOnPartialMethodDefinition2_CSharp8()
+        {
+            var code = @"
+using System;
+
 partial class C
 {
     partial void M(string s)
@@ -284,6 +355,37 @@ public partial void M(string s)
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
         public async Task TestOnPartialMethodImplementation1()
+        {
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+using System;
+
+partial class C
+{
+    partial void M(string s);
+
+    partial void M([||]string s)
+    {
+    }
+}",
+                FixedCode = @"
+using System;
+
+partial class C
+{
+    partial void M(string s);
+
+    partial void M(string s!!)
+    {
+    }
+}"
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestOnPartialMethodImplementation1_CSharp8()
         {
             await VerifyCS.VerifyRefactoringAsync(
 @"
@@ -351,6 +453,37 @@ public partial void M(string s)
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
         public async Task TestOnPartialMethodImplementation2()
+        {
+            await new VerifyCS.Test
+            {
+                LanguageVersion = LanguageVersion.Preview,
+                TestCode = @"
+using System;
+
+partial class C
+{
+    partial void M([||]string s)
+    {
+    }
+
+    partial void M(string s);
+}",
+                FixedCode = @"
+using System;
+
+partial class C
+{
+    partial void M(string s!!)
+    {
+    }
+
+    partial void M(string s);
+}"
+            }.RunAsync();
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsInitializeParameter)]
+        public async Task TestOnPartialMethodImplementation2_CSharp9()
         {
             await VerifyCS.VerifyRefactoringAsync(
 @"

src/Features/CSharp/Portable/InitializeParameter/CSharpAddParameterCheckCodeRefactoringProvider.cs

@@ -2,11 +2,10 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-#nullable disable
-
 using System;
 using System.Composition;
-using System.Diagnostics.CodeAnalysis;
+using System.Threading.Tasks;
+using System.Threading;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
@@ -92,5 +91,27 @@ protected override StatementSyntax CreateParameterCheckIfStatement(DocumentOptio
                 statement: ifTrueStatement,
                 @else: null);
         }
+
+        protected override async Task<Document?> TryAddNullCheckToParameterDeclarationAsync(Document document, IParameterSymbol parameter, CancellationToken cancellationToken)
+        {
+            var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false);
+            if (tree is null)
+            {
+                return null;
+            }
+
+            var options = (CSharpParseOptions)tree.Options;
+            if (options.LanguageVersion < LanguageVersion.Preview)
+            {
+                return null;
+            }
+
+            var syntaxRoot = await tree.GetRootAsync(cancellationToken).ConfigureAwait(false);
+            var syntax = (ParameterSyntax)await parameter.DeclaringSyntaxReferences[0].GetSyntaxAsync(cancellationToken).ConfigureAwait(false);
+            syntaxRoot = syntaxRoot.ReplaceNode(
+                syntax,
+                syntax.WithExclamationExclamationToken(Token(SyntaxKind.ExclamationExclamationToken)));
+            return document.WithSyntaxRoot(syntaxRoot);
+        }
     }
 }

src/Features/Core/Portable/InitializeParameter/AbstractAddParameterCheckCodeRefactoringProvider.cs

@@ -48,6 +48,10 @@ protected AbstractAddParameterCheckCodeRefactoringProvider()
         protected abstract bool PrefersThrowExpression(DocumentOptionSet options);
         protected abstract string EscapeResourceString(string input);
         protected abstract TStatementSyntax CreateParameterCheckIfStatement(DocumentOptionSet options, TExpressionSyntax condition, TStatementSyntax ifTrueStatement);
+        protected abstract Task<Document?> TryAddNullCheckToParameterDeclarationAsync(
+            Document document,
+            IParameterSymbol parameter,
+            CancellationToken cancellationToken);
 
         protected override async Task<ImmutableArray<CodeAction>> GetRefactoringsForAllParametersAsync(
             Document document, SyntaxNode functionDeclaration, IMethodSymbol methodSymbol,
@@ -318,8 +322,15 @@ private async Task<Document> AddNullCheckAsync(
             IBlockOperation? blockStatementOpt,
             CancellationToken cancellationToken)
         {
-            // First see if we can convert a statement of the form "this.s = s" into "this.s = s ?? throw ...".
-            var documentOpt = await TryAddNullCheckToAssignmentAsync(
+            // First see if we can adopt the '!!' parameter null checking syntax.
+            var documentOpt = await TryAddNullCheckToParameterDeclarationAsync(document, parameter, cancellationToken).ConfigureAwait(false);
+            if (documentOpt != null)
+            {
+                return documentOpt;
+            }
+
+            // Then see if we can convert a statement of the form "this.s = s" into "this.s = s ?? throw ...".
+            documentOpt = await TryAddNullCheckToAssignmentAsync(
                 document, parameter, blockStatementOpt, cancellationToken).ConfigureAwait(false);
 
             if (documentOpt != null)

src/Features/VisualBasic/Portable/InitializeParameter/VisualBasicAddParameterCheckCodeRefactoringProvider.vb

@@ -4,6 +4,7 @@
 
 Imports System.Composition
 Imports System.Diagnostics.CodeAnalysis
+Imports System.Threading
 Imports Microsoft.CodeAnalysis.CodeRefactorings
 Imports Microsoft.CodeAnalysis.Editing
 Imports Microsoft.CodeAnalysis.InitializeParameter
@@ -62,5 +63,9 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.InitializeParameter
                 elseIfBlocks:=Nothing,
                 elseBlock:=Nothing)
         End Function
+
+        Protected Overrides Function TryAddNullCheckToParameterDeclarationAsync(document As Document, parameter As IParameterSymbol, cancellationToken As CancellationToken) As Task(Of Document)
+            Return Task.FromResult(Of Document)(Nothing)
+        End Function
     End Class
 End Namespace

src/Workspaces/CSharpTest/Formatting/FormattingTests.cs

@@ -5775,6 +5775,28 @@ static object F()
             await AssertFormatAsync(expectedCode, code);
         }
 
+        [Fact]
+        [Trait(Traits.Feature, Traits.Features.Formatting)]
+        public async Task SpacingInNullCheckedParameter()
+        {
+            var code =
+@"class C
+{
+    static object F(string s !!)
+    {
+    }
+}";
+            var expectedCode =
+@"class C
+{
+    static object F(string s!!)
+    {
+    }
+}";
+
+            await AssertFormatAsync(expectedCode, code);
+        }
+
         [Fact]
         [WorkItem(545335, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/545335")]
         [Trait(Traits.Feature, Traits.Features.Formatting)]

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/TokenBasedFormattingRule.cs

@@ -478,6 +478,13 @@ SyntaxKind.ImplicitObjectCreationExpression or
                 return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
             }
 
+            // paramName!!
+            if (currentToken.Kind() == SyntaxKind.ExclamationExclamationToken &&
+                currentToken.Parent.IsKind(SyntaxKind.Parameter))
+            {
+                return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine);
+            }
+
             // pointer case for regular pointers
             if (currentToken.Kind() == SyntaxKind.AsteriskToken && currentToken.Parent is PointerTypeSyntax)
             {