Add VB tests.

src/EditorFeatures/CSharpTest/AddParameter/AddParameterTests.cs

@@ -460,7 +460,7 @@ private void Foo()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
-        public async Task TestNullArg()
+        public async Task TestNullArg1()
         {
             await TestInRegularAndScriptAsync(
 @"
@@ -488,6 +488,102 @@ void M()
     {
         new C(null, 1);
     }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
+        public async Task TestNullArg2()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    public C(string s) { }
+}
+
+class D
+{
+    void M()
+    {
+        new [|C|](null, 1);
+    }
+}",
+@"
+class C
+{
+    public C(string s, int v) { }
+}
+
+class D
+{
+    void M()
+    {
+        new C(null, 1);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
+        public async Task TestDefaultArg1()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    public C(int i) { }
+}
+
+class D
+{
+    void M()
+    {
+        new [|C|](default, 1);
+    }
+}",
+@"
+class C
+{
+    public C(int i, int v) { }
+}
+
+class D
+{
+    void M()
+    {
+        new C(default, 1);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)]
+        public async Task TestDefaultArg2()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    public C(string s) { }
+}
+
+class D
+{
+    void M()
+    {
+        new [|C|](default, 1);
+    }
+}",
+@"
+class C
+{
+    public C(string s, int v) { }
+}
+
+class D
+{
+    void M()
+    {
+        new C(default, 1);
+    }
 }");
         }
     }

src/EditorFeatures/VisualBasicTest/AddParameter/AddParameterTests.vb

@@ -54,6 +54,33 @@ class D
 end class")
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)>
+        Public Async Function TestNothingArgument1() As Task
+            Await TestInRegularAndScriptAsync(
+"
+class C
+    public sub new(i as integer)
+    end sub
+end class
+
+class D
+    sub M()
+        dim a = new C(nothing, [|1|])
+    end sub
+end class",
+"
+class C
+    public sub new(i as integer, v As Integer)
+    end sub
+end class
+
+class D
+    sub M()
+        dim a = new C(nothing, 1)
+    end sub
+end class")
+        End Function
+
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsAddParameter)>
         Public Async Function TestNamedArg() As Task
             Await TestInRegularAndScriptAsync(

src/Features/Core/Portable/AddParameter/AbstractAddParameterCodeFixProvider.cs

@@ -442,13 +442,15 @@ private int NonParamsParameterCount(IMethodSymbol method)
                     // don't match, then this is the argument we should make the parameter for.
                     var expressionOfArgumment = syntaxFacts.GetExpressionOfArgument(argument);
                     var argumentTypeInfo = semanticModel.GetTypeInfo(expressionOfArgumment);
+                    var isNullLiteral = syntaxFacts.IsNullLiteralExpression(expressionOfArgumment);
+                    var isDefaultLiteral = syntaxFacts.IsDefaultLiteralExpression(expressionOfArgumment);
+
                     if (argumentTypeInfo.Type == null && argumentTypeInfo.ConvertedType == null)
                     {
                         // Didn't know the type of the argument.  We shouldn't assume it doesn't
                         // match a parameter.  However, if the user wrote 'null' and it didn't
                         // match anything, then this is the problem argument.
-                        if (!syntaxFacts.IsNullLiteralExpression(expressionOfArgumment) &&
-                            !syntaxFacts.IsDefaultLiteralExpression(expressionOfArgumment))
+                        if (!isNullLiteral && !isDefaultLiteral)
                         {
                             continue;
                         }
@@ -456,9 +458,9 @@ private int NonParamsParameterCount(IMethodSymbol method)
 
                     var parameter = method.Parameters[i];
 
-                    if (!TypeInfoMatchesType(argumentTypeInfo, parameter.Type))
+                    if (!TypeInfoMatchesType(argumentTypeInfo, parameter.Type, isNullLiteral, isDefaultLiteral))
                     {
-                        if (TypeInfoMatchesWithParamsExpansion(argumentTypeInfo, parameter))
+                        if (TypeInfoMatchesWithParamsExpansion(argumentTypeInfo, parameter, isNullLiteral, isDefaultLiteral))
                         {
                             // The argument matched if we expanded out the params-parameter.
                             // As the params-parameter has to be last, there's nothing else to 
@@ -474,11 +476,13 @@ private int NonParamsParameterCount(IMethodSymbol method)
             return null;
         }
 
-        private bool TypeInfoMatchesWithParamsExpansion(TypeInfo argumentTypeInfo, IParameterSymbol parameter)
+        private bool TypeInfoMatchesWithParamsExpansion(
+            TypeInfo argumentTypeInfo, IParameterSymbol parameter, 
+            bool isNullLiteral, bool isDefaultLiteral)
         {
             if (parameter.IsParams && parameter.Type is IArrayTypeSymbol arrayType)
             {
-                if (TypeInfoMatchesType(argumentTypeInfo, arrayType.ElementType))
+                if (TypeInfoMatchesType(argumentTypeInfo, arrayType.ElementType, isNullLiteral, isDefaultLiteral))
                 {
                     return true;
                 }
@@ -487,8 +491,27 @@ private bool TypeInfoMatchesWithParamsExpansion(TypeInfo argumentTypeInfo, IPara
             return false;
         }
 
-        private bool TypeInfoMatchesType(TypeInfo argumentTypeInfo, ITypeSymbol type)
-            => type.Equals(argumentTypeInfo.Type) || type.Equals(argumentTypeInfo.ConvertedType);
+        private bool TypeInfoMatchesType(
+            TypeInfo argumentTypeInfo, ITypeSymbol type,
+            bool isNullLiteral, bool isDefaultLiteral)
+        {
+            if (type.Equals(argumentTypeInfo.Type) || type.Equals(argumentTypeInfo.ConvertedType))
+            {
+                return true;
+            }
+
+            if (isDefaultLiteral)
+            {
+                return true;
+            }
+
+            if (isNullLiteral)
+            {
+                return type.IsReferenceType || type.IsNullable();
+            }
+
+            return false;
+        }
 
         private class MyCodeAction : CodeAction.DocumentChangeAction
         {