Address CR comments

src/Compilers/CSharp/Portable/CommandLine/CSharpCommandLineParser.cs

@@ -1502,15 +1502,15 @@ public static IEnumerable<string> ParseConditionalCompilationSymbols(string valu
             return defines.AsEnumerable();
         }
 
-        public static bool TryParseLanguageVersion(string str, out LanguageVersion version)
+        public static bool TryParseLanguageVersion(string value, out LanguageVersion version)
         {
-            if (str == null)
+            if (value == null)
             {
                 version = LanguageVersion.Default;
                 return true;
             }
 
-            switch (str.ToLowerInvariant())
+            switch (value.ToLowerInvariant())
             {
                 case "iso-1":
                     version = LanguageVersion.CSharp1;
@@ -1529,7 +1529,7 @@ public static bool TryParseLanguageVersion(string str, out LanguageVersion versi
                     return true;
 
                 default:
-                    if (float.TryParse(str, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out float versionNumber))
+                    if (float.TryParse(value, NumberStyles.AllowDecimalPoint, CultureInfo.InvariantCulture, out float versionNumber))
                     {
                         if ((int)versionNumber == versionNumber && 1 <= versionNumber && versionNumber <= 7)
                         {

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -258,7 +258,7 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept(Microsoft.C
 override Microsoft.CodeAnalysis.CSharp.Syntax.TupleTypeSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
 override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void
 override Microsoft.CodeAnalysis.CSharp.Syntax.WhenClauseSyntax.Accept<TResult>(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor<TResult> visitor) -> TResult
-static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.TryParseLanguageVersion(string str, out Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> bool
+static Microsoft.CodeAnalysis.CSharp.CSharpCommandLineParser.TryParseLanguageVersion(string value, out Microsoft.CodeAnalysis.CSharp.LanguageVersion version) -> bool
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax declaratorSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.SingleVariableDesignationSyntax designationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol
 static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.TupleElementSyntax declarationSyntax, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.ISymbol

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

@@ -317,287 +317,5 @@ 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");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task RefReadOnlyWillPopUpInMethodReturnTypes()
-        {
-            var code = @"
-class Program
-{
-    public ref $$ int Test()
-    {
-        return ref x;
-    }
-}";
-
-            await VerifyItemExistsAsync(code, "readonly");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task RefReadOnlyWillPopUpInGlobalMemberDeclaration()
-        {
-            var code = @"
-public ref $$ ";
-
-            await VerifyItemExistsAsync(code, "readonly", sourceCodeKind: SourceCodeKind.Script);
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task RefReadOnlyWillPopUpInDelegateReturnType()
-        {
-            var code = @"
-public delegate ref $$ int Delegate();
-
-class Program
-{
-}";
-
-            await VerifyItemExistsAsync(code, "readonly");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task RefReadOnlyWillPopUpInMemberDeclaration()
-        {
-            var code = @"
-class Program
-{
-    public ref $$ int Test { get; set; }
-}";
-
-            await VerifyItemExistsAsync(code, "readonly");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task InWillPopUpInMethodReturnTypes()
-        {
-            var code = @"
-class Program
-{
-    public $$ int Test()
-    {
-        return ref x;
-    }
-}";
-
-            await VerifyItemExistsAsync(code, "in");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task InWillPopUpInGlobalMemberDeclaration()
-        {
-            var code = @"
-public $$ ";
-
-            await VerifyItemExistsAsync(code, "in", sourceCodeKind: SourceCodeKind.Script);
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task InWillPopUpInDelegateReturnType()
-        {
-            var code = @"
-public delegate $$ int Delegate();
-
-class Program
-{
-}";
-
-            await VerifyItemExistsAsync(code, "in");
-        }
-
-        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
-        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
-        public async Task InWillPopUpInMemberDeclaration()
-        {
-            var code = @"
-class Program
-{
-    public $$ int Test { get; set; }
-}";
-
-            await VerifyItemExistsAsync(code, "in");
-        }
     }
 }

src/EditorFeatures/CSharpTest2/Recommendations/InKeywordRecommenderTests.cs

@@ -301,5 +301,126 @@ void M()
     {
         var q = from Int32 $$");
         }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_Methods()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test($$ p) { }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_SecondParameter()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test(int p1, $$ p2) { }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_Delegates()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate($$ int p);");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_LocalFunctions()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test()
+    {
+        void localFunc($$ int p) { }
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_LambdaExpressions()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate lambda = ($$ int p) => p;
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpAsParameterModifier_AnonymousMethods()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate anonymousDelegate = delegate ($$ int p) { return p; };
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpInMethodReturnTypes()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public $$ int Test()
+    {
+        return ref x;
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpInGlobalMemberDeclaration()
+        {
+            await VerifyKeywordAsync(SourceCodeKind.Script, @"
+public $$ ");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpInDelegateReturnType()
+        {
+            await VerifyKeywordAsync(@"
+public delegate $$ int Delegate();
+
+class Program
+{
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task InWillPopUpInMemberDeclaration()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public $$ int Test { get; set; }
+}");
+        }
     }
 }

src/EditorFeatures/CSharpTest2/Recommendations/ReadOnlyKeywordRecommenderTests.cs

@@ -416,5 +416,126 @@ public async Task TestNotInMethod()
    void Foo() {
      $$");
         }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_Methods()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test(ref $$ p) { }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_SecondParameter()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test(int p1, ref $$ p2) { }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_Delegates()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate(ref $$ int p);");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_LocalFunctions()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public static void Test()
+    {
+        void localFunc(ref $$ int p) { }
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_LambdaExpressions()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate lambda = (ref $$ int p) => p;
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task ReadOnlyWillPopUpAfterRefInMethodParameterModifiers_AnonymousMethods()
+        {
+            await VerifyKeywordAsync(@"
+public delegate int Delegate(ref readonly int p);
+
+class Program
+{
+    public static void Test()
+    {
+        Delegate anonymousDelegate = delegate (ref $$ int p) { return p; };
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RefReadOnlyWillPopUpInMethodReturnTypes()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public ref $$ int Test()
+    {
+        return ref x;
+    }
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RefReadOnlyWillPopUpInGlobalMemberDeclaration()
+        {
+            await VerifyKeywordAsync(SourceCodeKind.Script, @"
+public ref $$ ");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RefReadOnlyWillPopUpInDelegateReturnType()
+        {
+            await VerifyKeywordAsync(@"
+public delegate ref $$ int Delegate();
+
+class Program
+{
+}");
+        }
+
+        [Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.ReadonlyReferences)]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.Completion)]
+        public async Task RefReadOnlyWillPopUpInMemberDeclaration()
+        {
+            await VerifyKeywordAsync(@"
+class Program
+{
+    public ref $$ int Test { get; set; }
+}");
+        }
     }
 }

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

@@ -72,7 +72,7 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
                 context.IsMemberDeclarationContext(
                     validModifiers: InMemberModifiers,
                     validTypeDeclarations: SyntaxKindSet.ClassInterfaceStructTypeDeclarations,
-                    canBePartial: true,
+                    canBePartial: false,
                     cancellationToken: cancellationToken);
         }
 

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

@@ -27,11 +27,9 @@ 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)) ||
+                IsRefReadOnlyContext(position, context) ||
                 context.SyntaxTree.IsGlobalMemberDeclarationContext(context.Position, SyntaxKindSet.AllGlobalMemberModifiers, cancellationToken) ||
                 context.IsMemberDeclarationContext(
                     validModifiers: s_validMemberModifiers,
@@ -39,5 +37,14 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context
                     canBePartial: false,
                     cancellationToken: cancellationToken);
         }
+
+        private bool IsRefReadOnlyContext(int position, CSharpSyntaxContext context)
+        {
+            var previousToken = context.LeftToken.GetPreviousTokenIfTouchingWord(position);
+
+            return
+                previousToken.IsKind(SyntaxKind.RefKeyword) &&
+                previousToken.Parent.IsKind(SyntaxKind.Parameter, SyntaxKind.RefType);
+        }
     }
 }

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

@@ -9,7 +9,7 @@ namespace Microsoft.CodeAnalysis.CSharp.Extensions.ContextQuery
 {
     internal static class SyntaxNodeExtensions
     {
-        public static bool IsDelegateOrConstructorOrMethodParameterList(this SyntaxNode node)
+        public static bool IsDelegateOrConstructorOrLocalFunctionOrMethodParameterList(this SyntaxNode node)
         {
             if (!node.IsKind(SyntaxKind.ParameterList))
             {

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

@@ -989,7 +989,7 @@ public static bool IsDefaultExpressionContext(this SyntaxTree syntaxTree, int po
             token = token.GetPreviousTokenIfTouchingWord(position);
 
             if (token.IsKind(SyntaxKind.OpenParenToken) &&
-                token.Parent.IsDelegateOrConstructorOrMethodParameterList())
+                token.Parent.IsDelegateOrConstructorOrLocalFunctionOrMethodParameterList())
             {
                 if (allowableIndex.HasValue)
                 {
@@ -1003,7 +1003,7 @@ public static bool IsDefaultExpressionContext(this SyntaxTree syntaxTree, int po
             }
 
             if (token.IsKind(SyntaxKind.CommaToken) &&
-                token.Parent.IsDelegateOrConstructorOrMethodParameterList())
+                token.Parent.IsDelegateOrConstructorOrLocalFunctionOrMethodParameterList())
             {
                 if (allowableIndex.HasValue)
                 {
@@ -1022,7 +1022,7 @@ public static bool IsDefaultExpressionContext(this SyntaxTree syntaxTree, int po
             if (token.IsKind(SyntaxKind.CloseBracketToken) &&
                 token.Parent.IsKind(SyntaxKind.AttributeList) &&
                 token.Parent.IsParentKind(SyntaxKind.Parameter) &&
-                token.Parent.GetParent().GetParent().IsDelegateOrConstructorOrMethodParameterList())
+                token.Parent.GetParent().GetParent().IsDelegateOrConstructorOrLocalFunctionOrMethodParameterList())
             {
                 if (allowableIndex.HasValue)
                 {