IntroduceLocal on simple names (#25856)

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

@@ -4616,6 +4616,173 @@ void M()
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestSimpleParameterName()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    void M(int a)
+    {
+        System.Console.Write([|a|]);
+    }
+}",
+@"
+class C
+{
+    void M(int a)
+    {
+        int {|Rename:a1|} = a;
+        System.Console.Write(a1);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestSimpleParamterName_EmptySelection()
+        {
+            await TestMissingAsync(
+@"class C
+{
+    void M(int a)
+    {
+        System.Console.Write([||]a);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestSimpleParamterName_SmallSelection()
+        {
+            await TestMissingAsync(
+@"class C
+{
+    void M(int parameter)
+    {
+        System.Console.Write([|par|]ameter);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithThis()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    int a;
+    void M()
+    {
+        System.Console.Write([|this.a|]);
+    }
+}",
+@"
+class C
+{
+    int a;
+    void M()
+    {
+        int {|Rename:a1|} = this.a;
+        System.Console.Write(a1);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithType()
+        {
+            await TestInRegularAndScriptAsync(
+@"
+class C
+{
+    static int a;
+    void M()
+    {
+        System.Console.Write([|C.a|]);
+    }
+}",
+@"
+class C
+{
+    static int a;
+    void M()
+    {
+        int {|Rename:a1|} = C.a;
+        System.Console.Write(a1);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithType_TinySelection1()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    static int a;
+    void M()
+    {
+        System.Console.Write(C[|.|]a);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithType_TinySelection2()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    static int a;
+    void M()
+    {
+        System.Console.Write([|C.|]a);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithType_TinySelection3()
+        {
+            await TestMissingAsync(
+@"
+class C
+{
+    static int a;
+    void M()
+    {
+        System.Console.Write(C.[|a|]);
+    }
+}");
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
+        [WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")]
+        public async Task TestFieldName_QualifiedWithType_EmptySelection()
+        {
+            await TestMissingAsync(
+@"class C
+{
+    static int a;
+    void M()
+    {
+        System.Console.Write(C.[||]a);
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)]
         public async Task TestIntroduceLocalInCallRefExpression()
         {

src/EditorFeatures/VisualBasicTest/CodeActions/IntroduceVariable/IntroduceVariableTests.vb

@@ -2953,6 +2953,72 @@ structure TextSpan
 end structure")
         End Function
 
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)>
+        <WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")>
+        Public Async Function TestSimpleParameterName() As Task
+            Dim source = "Module Program
+    Sub Main(x As Integer)
+        Goo([|x|])
+    End Sub
+End Module"
+            Dim expected = "Module Program
+    Sub Main(x As Integer)
+        Dim {|Rename:x1|} As Integer = x
+        Goo(x1)
+    End Sub
+End Module"
+            Await TestInRegularAndScriptAsync(source, expected)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)>
+        <WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")>
+        Public Async Function TestSimpleParameterName_EmptySelection() As Task
+            Dim source = "Module Program
+    Sub Main(x As Integer)
+        Goo([||]x)
+    End Sub
+End Module"
+            Await TestMissingAsync(source)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)>
+        <WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")>
+        Public Async Function TestFieldName_QualifiedWithMe() As Task
+            Dim source = "Module Program
+    Dim x As Integer
+    Sub Main()
+        Goo([|x|])
+    End Sub
+End Module"
+            Dim expected = "Module Program
+    Dim x As Integer
+    Sub Main()
+        Dim {|Rename:x1|} As Integer = x
+        Goo(x1)
+    End Sub
+End Module"
+            Await TestInRegularAndScriptAsync(source, expected)
+        End Function
+
+        <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)>
+        <WorkItem(10123, "https://github.com/dotnet/roslyn/issues/10123")>
+        Public Async Function TestFieldName_QualifiedWithType() As Task
+            Dim source = "Module Program
+    Shared Dim x As Integer
+    Sub Main()
+        Goo([|Program.x|])
+    End Sub
+End Module"
+            Dim expected = "Module Program
+    Shared Dim x As Integer
+    Sub Main()
+        Dim {|Rename:x1|} As Integer = Program.x
+        Goo(x1)
+    End Sub
+End Module"
+            Await TestInRegularAndScriptAsync(source, expected)
+        End Function
+
         <WorkItem(21373, "https://github.com/dotnet/roslyn/issues/21373")>
         <Fact, Trait(Traits.Feature, Traits.Features.CodeActionsIntroduceVariable)>
         Public Async Function TestInAttribute() As Task

src/Features/CSharp/Portable/IntroduceVariable/CSharpIntroduceVariableService.cs

@@ -16,7 +16,7 @@ namespace Microsoft.CodeAnalysis.CSharp.IntroduceVariable
 {
     [ExportLanguageService(typeof(IIntroduceVariableService), LanguageNames.CSharp), Shared]
     internal partial class CSharpIntroduceVariableService :
-        AbstractIntroduceVariableService<CSharpIntroduceVariableService, ExpressionSyntax, TypeSyntax, TypeDeclarationSyntax, QueryExpressionSyntax>
+        AbstractIntroduceVariableService<CSharpIntroduceVariableService, ExpressionSyntax, TypeSyntax, TypeDeclarationSyntax, QueryExpressionSyntax, NameSyntax>
     {
         protected override bool IsInNonFirstQueryClause(ExpressionSyntax expression)
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.AbstractIntroduceVariableCodeAction.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         internal abstract class AbstractIntroduceVariableCodeAction : CodeAction
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.CodeAction.cs

@@ -3,7 +3,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private class IntroduceVariableCodeAction : AbstractIntroduceVariableCodeAction
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.IntroduceVariableAllOccurrenceCodeAction.cs

@@ -8,7 +8,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private class IntroduceVariableAllOccurrenceCodeAction : AbstractIntroduceVariableCodeAction
         {

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

@@ -10,7 +10,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {
@@ -82,7 +82,7 @@ public State(TService service, SemanticDocument document)
                     return false;
                 }
 
-                if (!CanIntroduceVariable(cancellationToken))
+                if (!CanIntroduceVariable(textSpan.IsEmpty, cancellationToken))
                 {
                     return false;
                 }
@@ -229,6 +229,7 @@ private TExpressionSyntax GetExpressionUnderSpan(SyntaxTree tree, TextSpan textS
             }
 
             private bool CanIntroduceVariable(
+                bool isSpanEmpty,
                 CancellationToken cancellationToken)
             {
                 if (!_service.CanIntroduceVariableFor(this.Expression))
@@ -236,8 +237,15 @@ private TExpressionSyntax GetExpressionUnderSpan(SyntaxTree tree, TextSpan textS
                     return false;
                 }
 
-                if (this.Expression is TTypeSyntax)
+                if (isSpanEmpty && this.Expression is TNameSyntax)
                 {
+                    // to extract a name, you must have a selection (this avoids making the refactoring too noisy)
+                    return false;
+                }
+
+                if (this.Expression is TTypeSyntax && !(this.Expression is TNameSyntax))
+                {
+                    // name syntax can introduce variables, but not other type syntaxes
                     return false;
                 }
 

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_Attribute.cs

@@ -4,7 +4,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_Block.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_ConstructorInitializer.cs

@@ -7,7 +7,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_Field.cs

@@ -7,7 +7,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_Parameter.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

src/Features/Core/Portable/IntroduceVariable/AbstractIntroduceVariableService.State_Query.cs

@@ -6,7 +6,7 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
     {
         private partial class State
         {

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

@@ -18,12 +18,13 @@
 
 namespace Microsoft.CodeAnalysis.IntroduceVariable
 {
-    internal abstract partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax> : IIntroduceVariableService
-        where TService : AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax>
+    internal abstract partial class AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax> : IIntroduceVariableService
+        where TService : AbstractIntroduceVariableService<TService, TExpressionSyntax, TTypeSyntax, TTypeDeclarationSyntax, TQueryExpressionSyntax, TNameSyntax>
         where TExpressionSyntax : SyntaxNode
         where TTypeSyntax : TExpressionSyntax
         where TTypeDeclarationSyntax : SyntaxNode
         where TQueryExpressionSyntax : TExpressionSyntax
+        where TNameSyntax : TTypeSyntax
     {
         protected abstract bool IsInNonFirstQueryClause(TExpressionSyntax expression);
         protected abstract bool IsInFieldInitializer(TExpressionSyntax expression);

src/Features/VisualBasic/Portable/IntroduceVariable/VisualBasicIntroduceVariableService.vb

@@ -10,8 +10,8 @@ Imports System.Composition
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.IntroduceVariable
     <ExportLanguageService(GetType(IIntroduceVariableService), LanguageNames.VisualBasic), [Shared]>
-    Friend Class VisualBasicIntroduceVariableService
-        Inherits AbstractIntroduceVariableService(Of VisualBasicIntroduceVariableService, ExpressionSyntax, TypeSyntax, TypeBlockSyntax, QueryExpressionSyntax)
+    Partial Friend Class VisualBasicIntroduceVariableService
+        Inherits AbstractIntroduceVariableService(Of VisualBasicIntroduceVariableService, ExpressionSyntax, TypeSyntax, TypeBlockSyntax, QueryExpressionSyntax, NameSyntax)
 
         Protected Overrides Function GetContainingExecutableBlocks(expression As ExpressionSyntax) As IEnumerable(Of SyntaxNode)
             Return expression.GetContainingExecutableBlocks()