Work some 'scoped' issues on IDE

src/EditorFeatures/CSharpTest/Classification/TotalClassifierTests.cs

@@ -2616,5 +2616,44 @@ static void staticLocalFunction() { }|]
                 Punctuation.OpenCurly,
                 Punctuation.CloseCurly);
         }
+
+        [Theory]
+        [CombinatorialData]
+        public async Task TestScopedVar(TestHost testHost)
+        {
+            await TestAsync("""
+                static void method(scoped in S s)
+                {
+                    scoped var rs1 = s;
+                }
+
+                file readonly ref struct S { }
+                """, testHost,
+                Keyword("static"),
+                Keyword("void"),
+                Method("method"),
+                Static("method"),
+                Punctuation.OpenParen,
+                Keyword("scoped"),
+                Keyword("in"),
+                Struct("S"),
+                Parameter("s"),
+                Punctuation.CloseParen,
+                Punctuation.OpenCurly,
+                Keyword("scoped"),
+                Keyword("var"),
+                Local("rs1"),
+                Operators.Equals,
+                Parameter("s"),
+                Punctuation.Semicolon,
+                Punctuation.CloseCurly,
+                Keyword("file"),
+                Keyword("readonly"),
+                Keyword("ref"),
+                Keyword("struct"),
+                Struct("S"),
+                Punctuation.OpenCurly,
+                Punctuation.CloseCurly);
+        }
     }
 }

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

@@ -11896,6 +11896,50 @@ class C
             await VerifyAnyItemExistsAsync(source);
         }
 
+        [Fact]
+        public async Task AfterScopedInsideMethod()
+        {
+            var source = @"
+class C
+{
+    void M()
+    {
+        scoped $$
+    }
+}
+
+ref struct MyRefStruct { }
+";
+            await VerifyItemExistsAsync(MakeMarkup(source), "MyRefStruct");
+        }
+
+        [Fact]
+        public async Task AfterScopedGlobalStatement()
+        {
+            var source = @"
+scoped $$
+
+ref struct MyRefStruct { }
+";
+            await VerifyItemExistsAsync(MakeMarkup(source), "MyRefStruct");
+        }
+
+        [Fact]
+        public async Task AfterScopedInParameter()
+        {
+            var source = @"
+class C
+{
+    void M(scoped $$)
+    {
+    }
+}
+
+ref struct MyRefStruct { }
+";
+            await VerifyItemExistsAsync(MakeMarkup(source), "MyRefStruct");
+        }
+
         private static string MakeMarkup(string source, string languageVersion = "Preview")
         {
             return $$"""

src/EditorFeatures/CSharpTest/ReassignedVariable/CSharpReassignedVariableTests.cs

@@ -500,13 +500,21 @@ await TestAsync(
 using System;
 class C
 {
-    void M(ref int [|p|])
+    void M1(ref int [|p|])
     {
         ref var [|local|] = ref [|p|];
         [|local|] = 0;
         [|local|] = 1;
         Console.WriteLine([|local|]);
     }
+
+    void M2(ref int [|p|])
+    {
+        scoped ref var [|local|] = ref [|p|];
+        [|local|] = 0;
+        [|local|] = 1;
+        Console.WriteLine([|local|]);
+    }
 }");
         }
 
@@ -644,12 +652,19 @@ await TestAsync(
 using System;
 class C
 {
-    void M()
+    void M1()
     {
         int p = 0;
         ref readonly int refP = ref p;
         Console.WriteLine(p);
     }
+
+    void M2()
+    {
+        int p = 0;
+        scoped ref readonly int refP = ref p;
+        Console.WriteLine(p);
+    }
 }");
         }
 
@@ -661,12 +676,19 @@ await TestAsync(
 using System;
 class C
 {
-    void M()
+    void M1()
     {
         int p = 0;
         ref readonly int refP = ref p!;
         Console.WriteLine(p);
     }
+
+    void M2()
+    {
+        int p = 0;
+        scoped ref readonly int refP = ref p!;
+        Console.WriteLine(p);
+    }
 }");
         }
 

src/EditorFeatures/CSharpTest2/Recommendations/GlobalKeywordRecommenderTests.cs

@@ -349,5 +349,12 @@ await VerifyKeywordAsync(
 @"$$
 [assembly: Call()]");
         }
+
+        [Fact]
+        public async Task TestAfterScoped()
+        {
+            await VerifyKeywordAsync("scoped $$");
+            await VerifyKeywordAsync(AddInsideMethod("scoped $$"));
+        }
     }
 }