Keyword recommendations in parameters

src/EditorFeatures/CSharpTest/Completion/CompletionProviders/KeywordCompletionProviderTests.cs

@@ -317,5 +317,181 @@ public async Task FormattingAfterCompletionCommit_InSingleLineMethod()
 }";
             await VerifyProviderCommitAsync(markupBeforeCommit, "return", expectedCodeAfterCommit, commitChar: ';', textTypedSoFar: "return");
         }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_Methods()
+        {
+            var code = @"
+class Program
+{
+    public static void Test(ref $$ p) { }
+}";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_SecondParameter()
+        {
+            var code = @"
+class Program
+{
+    public static void Test(int p1, ref $$ p2) { }
+}";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_Delegates()
+        {
+            var code = @"
+public delegate int Delegate(ref $$ int p);";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_LocalFunctions()
+        {
+            var code = @"
+class Program
+{
+    public static void Test()
+    {
+        void localFunc(ref $$ int p) { }
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_LambdaExpressions()
+        {
+            var code = @"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate lambda = (ref $$ int p) => p;
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_AnonymousMethods()
+        {
+            var code = @"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate anonymousDelegate = delegate (ref $$ int p) { return p; };
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "readonly");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_Methods()
+        {
+            var code = @"
+class Program
+{
+    public static void Test($$ p) { }
+}";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_SecondParameter()
+        {
+            var code = @"
+class Program
+{
+    public static void Test(int p1, $$ p2) { }
+}";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_Delegates()
+        {
+            var code = @"
+public delegate int Delegate($$ int p);";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_LocalFunctions()
+        {
+            var code = @"
+class Program
+{
+    public static void Test()
+    {
+        void localFunc($$ int p) { }
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_LambdaExpressions()
+        {
+            var code = @"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate lambda = ($$ int p) => p;
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_AnonymousMethods()
+        {
+            var code = @"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate anonymousDelegate = delegate ($$ int p) { return p; };
+    }
+}";
+
+            await VerifyItemExistsAsync(code, "in");
+        }
     }
 }

src/Features/CSharp/Portable/Completion/KeywordRecommenders/InKeywordRecommender.cs

@@ -21,7 +21,10 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
                 IsValidContextInForEachClause(context) ||
                 IsValidContextInFromClause(context, cancellationToken) ||
                 IsValidContextInJoinClause(context, cancellationToken) ||
-                context.TargetToken.IsTypeParameterVarianceContext();
+                context.TargetToken.IsTypeParameterVarianceContext() ||
+                context.SyntaxTree.IsParameterModifierContext(position, context.LeftToken, cancellationToken) ||
+                context.SyntaxTree.IsAnonymousMethodParameterModifierContext(position, context.LeftToken, cancellationToken) ||
+                context.SyntaxTree.IsPossibleLambdaParameterModifierContext(position, context.LeftToken, cancellationToken);
         }
 
         private bool IsValidContextInForEachClause(CSharpSyntaxContext context)

src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
 using Microsoft.CodeAnalysis.CSharp.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Completion.KeywordRecommenders
@@ -26,8 +27,11 @@ public ReadOnlyKeywordRecommender()
 
         protected override bool IsValidContext(int position, CSharpSyntaxContext context, CancellationToken cancellationToken)
         {
+            var previousToken = context.LeftToken.GetPreviousTokenIfTouchingWord(position);
+
             return
                 context.IsGlobalStatementContext ||
+                (previousToken.IsKind(SyntaxKind.RefKeyword) && previousToken.Parent.IsKind(SyntaxKind.Parameter, SyntaxKind.RefType)) ||
                 context.SyntaxTree.IsGlobalMemberDeclarationContext(context.Position, SyntaxKindSet.AllGlobalMemberModifiers, cancellationToken) ||
                 context.IsMemberDeclarationContext(
                     validModifiers: s_validMemberModifiers,

src/Workspaces/CSharp/Portable/Extensions/ContextQuery/SyntaxNodeExtensions.cs

@@ -18,6 +18,7 @@ public static bool IsDelegateOrConstructorOrMethodParameterList(this SyntaxNode
 
             return
                 node.IsParentKind(SyntaxKind.MethodDeclaration) ||
+                node.IsParentKind(SyntaxKind.LocalFunctionStatement) ||
                 node.IsParentKind(SyntaxKind.ConstructorDeclaration) ||
                 node.IsParentKind(SyntaxKind.DelegateDeclaration);
         }