Introduce Constants should not be offered for Nulls

Don't offer Introduce Constants on NullLiterals. They could cause
semantic errors when used in a replace all occurrences context and are
offer no value anyway.

src/EditorFeatures/CSharpTest/CodeActions/IntroduceVariable/IntroduceVariableTests.cs

@@ -613,13 +613,12 @@ public void TestMissingOnVariableWrite()
         }
 
         [WorkItem(544577)]
+        [WorkItem(909152)]
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public void TestExpressionTLambda()
         {
-            Test(
-@"using System ; using System . Linq . Expressions ; class Program { static Expression < Func < int ? , char ? > > e1 = c => [|null|] ; } ",
-@"using System ; using System . Linq . Expressions ; class Program { private const char ? {|Rename:P|} = null ; static Expression < Func < int ? , char ? > > e1 = c => P ; } ",
-index: 1);
+            TestMissing(
+@"using System ; using System . Linq . Expressions ; class Program { static Expression < Func < int ? , char ? > > e1 = c => [|null|] ; } ");
         }
 
         [WorkItem(544915)]
@@ -2323,5 +2322,23 @@ class TestClass
 
             Test(code, expected, index: 2, compareTokens: false);
         }
+
+        [WorkItem(909152)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        public void TestMissingOnNullLiteral()
+        {
+            TestMissing(
+@"class C1 { }
+class C2 { }
+class Test
+{
+    void M()
+    {
+        C1 c1 = [|null|];
+        C2 c2 = null;
+    }
+}
+");
+        }
     }
 }

src/Features/CSharp/IntroduceVariable/CSharpIntroduceVariableService.cs

@@ -96,13 +96,24 @@ protected override bool IsInAttributeArgumentInitializer(ExpressionSyntax expres
             return false;
         }
 
+        /// <summary>
+        /// Checks for conditions where we should not generate a variable for an expression
+        /// </summary>
         protected override bool CanIntroduceVariableFor(ExpressionSyntax expression)
         {
+            // (a) If that's the only expression in a statement.
+            // Otherwise we'll end up with something like "v;" which is not legal in C#.
             if (expression.WalkUpParentheses().IsParentKind(SyntaxKind.ExpressionStatement))
             {
                 return false;
             }
 
+            // (b) For Null Literals, as AllOccurences could introduce semantic errors.
+            if (expression is LiteralExpressionSyntax && ((LiteralExpressionSyntax)expression).IsKind(SyntaxKind.NullLiteralExpression))
+            {
+                return false;
+            }
+
             return true;
         }
 

src/Features/Core/IntroduceVariable/AbstractIntroduceVariableService.State.cs

@@ -216,9 +216,6 @@ private TExpressionSyntax GetExpressionUnderSpan(SyntaxTree tree, TextSpan textS
             private bool CanIntroduceVariable(
                 CancellationToken cancellationToken)
             {
-                // Don't generate a variable for an expression that's the only expression in a
-                // statement.  Otherwise we'll end up with something like "v;" which is not
-                // legal in C#.
                 if (!_service.CanIntroduceVariableFor(this.Expression))
                 {
                     return false;