Support 'scoped' modifier for parameters and locals

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.Members.cs

@@ -767,9 +767,23 @@ public override void VisitParameter(IParameterSymbol symbol)
 
             if (includeType)
             {
+                if (symbol.IsRefScoped &&
+                    format.ParameterOptions.IncludesOption(SymbolDisplayParameterOptions.IncludeScoped))
+                {
+                    AddKeyword(SyntaxKind.ScopedKeyword);
+                    AddSpace();
+                }
+
                 AddParameterRefKindIfRequired(symbol.RefKind);
                 AddCustomModifiersIfRequired(symbol.RefCustomModifiers, leadingSpace: false, trailingSpace: true);
 
+                if (symbol.IsValueScoped &&
+                    format.ParameterOptions.IncludesOption(SymbolDisplayParameterOptions.IncludeScoped))
+                {
+                    AddKeyword(SyntaxKind.ScopedKeyword);
+                    AddSpace();
+                }
+
                 if (symbol.IsParams && format.ParameterOptions.IncludesOption(SymbolDisplayParameterOptions.IncludeParamsRefOut))
                 {
                     AddKeyword(SyntaxKind.ParamsKeyword);

src/Compilers/CSharp/Portable/SymbolDisplay/SymbolDisplayVisitor.cs

@@ -190,6 +190,13 @@ public override void VisitLocal(ILocalSymbol symbol)
             if (symbol.IsRef &&
                 format.LocalOptions.IncludesOption(SymbolDisplayLocalOptions.IncludeRef))
             {
+                if (symbol.IsRefScoped &&
+                    format.LocalOptions.IncludesOption(SymbolDisplayLocalOptions.IncludeScoped))
+                {
+                    AddKeyword(SyntaxKind.ScopedKeyword);
+                    AddSpace();
+                }
+
                 AddKeyword(SyntaxKind.RefKeyword);
                 AddSpace();
 
@@ -200,6 +207,13 @@ public override void VisitLocal(ILocalSymbol symbol)
                 }
             }
 
+            if (symbol.IsValueScoped &&
+                format.LocalOptions.IncludesOption(SymbolDisplayLocalOptions.IncludeScoped))
+            {
+                AddKeyword(SyntaxKind.ScopedKeyword);
+                AddSpace();
+            }
+
             if (format.LocalOptions.IncludesOption(SymbolDisplayLocalOptions.IncludeType))
             {
                 symbol.Type.Accept(this.NotFirstVisitor);

src/Compilers/CSharp/Portable/Symbols/DeclarationScope.cs

@@ -6,6 +6,8 @@
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
+    // PROTOTYPE: Remove and use separate IsRefScoped and IsValueScoped
+    // properties on LocalSymbol and ParameterSymbol, to match the public API.
     [Flags]
     internal enum DeclarationScope : byte
     {

src/Compilers/CSharp/Portable/Symbols/PublicModel/LocalSymbol.cs

@@ -51,6 +51,10 @@ bool ILocalSymbol.IsFunctionValue
 
         RefKind ILocalSymbol.RefKind => _underlying.RefKind;
 
+        bool ILocalSymbol.IsRefScoped => (_underlying.Scope & DeclarationScope.RefScoped) != 0;
+
+        bool ILocalSymbol.IsValueScoped => (_underlying.Scope & DeclarationScope.ValueScoped) != 0;
+
         bool ILocalSymbol.HasConstantValue => _underlying.HasConstantValue;
 
         object ILocalSymbol.ConstantValue => _underlying.ConstantValue;

src/Compilers/CSharp/Portable/Symbols/PublicModel/ParameterSymbol.cs

@@ -58,6 +58,10 @@ IParameterSymbol IParameterSymbol.OriginalDefinition
 
         RefKind IParameterSymbol.RefKind => _underlying.RefKind;
 
+        bool IParameterSymbol.IsRefScoped => (_underlying.Scope & DeclarationScope.RefScoped) != 0;
+
+        bool IParameterSymbol.IsValueScoped => (_underlying.Scope & DeclarationScope.ValueScoped) != 0;
+
         bool IParameterSymbol.IsDiscard => _underlying.IsDiscard;
 
         bool IParameterSymbol.IsParams => _underlying.IsParams;

src/Compilers/CSharp/Test/Semantic/Semantics/RefFieldTests.cs

@@ -4501,11 +4501,25 @@ static void Main()
             VerifyParameterSymbol(method.Parameters[1], "scoped in System.Int32 y", RefKind.In, DeclarationScope.RefScoped);
         }
 
+        private static readonly SymbolDisplayFormat displayFormatWithScoped = SymbolDisplayFormat.TestFormat.
+            AddParameterOptions(SymbolDisplayParameterOptions.IncludeScoped).
+            AddLocalOptions(SymbolDisplayLocalOptions.IncludeRef | SymbolDisplayLocalOptions.IncludeScoped);
+
         private static void VerifyParameterSymbol(ParameterSymbol parameter, string expectedDisplayString, RefKind expectedRefKind, DeclarationScope scope)
         {
             Assert.Equal(expectedRefKind, parameter.RefKind);
             Assert.Equal(scope, parameter.Scope);
-            Assert.Equal(expectedDisplayString.Replace("scoped ", ""), parameter.ToTestDisplayString()); // PROTOTYPE: Remove string.Replace().
+            Assert.Equal(expectedDisplayString, parameter.ToDisplayString(displayFormatWithScoped));
+
+            VerifyParameterSymbol(parameter.GetPublicSymbol(), expectedDisplayString, expectedRefKind, scope);
+        }
+
+        private static void VerifyParameterSymbol(IParameterSymbol parameter, string expectedDisplayString, RefKind expectedRefKind, DeclarationScope scope)
+        {
+            Assert.Equal(expectedRefKind, parameter.RefKind);
+            Assert.Equal((scope & DeclarationScope.RefScoped) != 0, parameter.IsRefScoped);
+            Assert.Equal((scope & DeclarationScope.ValueScoped) != 0, parameter.IsValueScoped);
+            Assert.Equal(expectedDisplayString, parameter.ToDisplayString(displayFormatWithScoped));
         }
 
         [Fact]
@@ -4630,15 +4644,24 @@ public void LocalScope_04()
             var decls = tree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().ToArray();
             var locals = decls.Select(d => model.GetDeclaredSymbol(d).GetSymbol<LocalSymbol>()).ToArray();
 
-            VerifyLocalSymbol(locals[0], "scoped s1", RefKind.None, DeclarationScope.None);
+            VerifyLocalSymbol(locals[0], "System.Boolean scoped", RefKind.None, DeclarationScope.None);
         }
 
         private static void VerifyLocalSymbol(LocalSymbol local, string expectedDisplayString, RefKind expectedRefKind, DeclarationScope scope)
         {
             Assert.Equal(expectedRefKind, local.RefKind);
             Assert.Equal(scope, local.Scope);
-            // PROTOTYPE: Enable after adding 'scoped' to SymbolDisplay.
-            //Assert.Equal(expectedDisplayString.Replace("scoped ", ""), local.ToTestDisplayString());
+            Assert.Equal(expectedDisplayString, local.ToDisplayString(displayFormatWithScoped));
+
+            VerifyLocalSymbol(local.GetPublicSymbol(), expectedDisplayString, expectedRefKind, scope);
+        }
+
+        private static void VerifyLocalSymbol(ILocalSymbol local, string expectedDisplayString, RefKind expectedRefKind, DeclarationScope scope)
+        {
+            Assert.Equal(expectedRefKind, local.RefKind);
+            Assert.Equal((scope & DeclarationScope.RefScoped) != 0, local.IsRefScoped);
+            Assert.Equal((scope & DeclarationScope.ValueScoped) != 0, local.IsValueScoped);
+            Assert.Equal(expectedDisplayString, local.ToDisplayString(displayFormatWithScoped));
         }
 
         [Fact]

src/Compilers/CSharp/Test/Symbol/SymbolDisplay/SymbolDisplayTests.cs

@@ -8034,5 +8034,163 @@ ref struct S<T>
                 SymbolDisplayPartKind.Punctuation,
                 SymbolDisplayPartKind.FieldName);
         }
+
+        [Fact]
+        public void ScopedParameter()
+        {
+            var source =
+@"ref struct R { }
+class Program
+{
+    static void F(scoped R r1, in scoped R r2, scoped ref R r3) { }
+}";
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+            var method = comp.GetMember<MethodSymbol>("Program.F");
+
+            var formatWithoutScoped = SymbolDisplayFormat.TestFormat;
+            var formatWithScoped = formatWithoutScoped.AddParameterOptions(SymbolDisplayParameterOptions.IncludeScoped);
+
+            Verify(method.ToDisplayParts(formatWithoutScoped),
+                "void Program.F(R r1, in R r2, ref R r3)",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ClassName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.MethodName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation);
+
+            Verify(method.ToDisplayParts(formatWithScoped),
+                "void Program.F(scoped R r1, in scoped R r2, scoped ref R r3)",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ClassName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.MethodName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.ParameterName,
+                SymbolDisplayPartKind.Punctuation);
+        }
+
+        [Fact]
+        public void ScopedLocal()
+        {
+            var source =
+@"ref struct R { }
+class Program
+{
+    static void Main()
+    {
+        scoped R r1;
+        ref readonly scoped R r2 = ref r1;
+        scoped ref R r3 = ref r1;
+    }
+}";
+
+            var comp = CreateCompilation(source);
+            comp.VerifyDiagnostics();
+            var tree = comp.SyntaxTrees[0];
+            var model = comp.GetSemanticModel(tree);
+            var decls = tree.GetRoot().DescendantNodes().OfType<VariableDeclaratorSyntax>().ToArray();
+            var locals = decls.Select(d => model.GetDeclaredSymbol(d)).ToArray();
+
+            var formatWithoutScoped = SymbolDisplayFormat.TestFormat.AddLocalOptions(SymbolDisplayLocalOptions.IncludeRef);
+            var formatWithScoped = formatWithoutScoped.AddLocalOptions(SymbolDisplayLocalOptions.IncludeScoped);
+
+            Verify(locals[0].ToDisplayParts(formatWithoutScoped),
+                "R r1",
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+
+            Verify(locals[0].ToDisplayParts(formatWithScoped),
+                "scoped R r1",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+
+            Verify(locals[1].ToDisplayParts(formatWithoutScoped),
+                "ref readonly R r2",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+
+            Verify(locals[1].ToDisplayParts(formatWithScoped),
+                "ref readonly scoped R r2",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+
+            Verify(locals[2].ToDisplayParts(formatWithoutScoped),
+                "ref R r3",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+
+            Verify(locals[2].ToDisplayParts(formatWithScoped),
+                "scoped ref R r3",
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.Keyword,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.StructName,
+                SymbolDisplayPartKind.Space,
+                SymbolDisplayPartKind.LocalName);
+        }
     }
 }

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

@@ -8,6 +8,8 @@ Microsoft.CodeAnalysis.IImportScope.Aliases.get -> System.Collections.Immutable.
 Microsoft.CodeAnalysis.IImportScope.ExternAliases.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IAliasSymbol!>
 Microsoft.CodeAnalysis.IImportScope.Imports.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ImportedNamespaceOrType>
 Microsoft.CodeAnalysis.IImportScope.XmlNamespaces.get -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.ImportedXmlNamespace>
+Microsoft.CodeAnalysis.ILocalSymbol.IsRefScoped.get -> bool
+Microsoft.CodeAnalysis.ILocalSymbol.IsValueScoped.get -> bool
 Microsoft.CodeAnalysis.ImportedNamespaceOrType
 Microsoft.CodeAnalysis.ImportedNamespaceOrType.DeclaringSyntaxReference.get -> Microsoft.CodeAnalysis.SyntaxReference?
 Microsoft.CodeAnalysis.ImportedNamespaceOrType.ImportedNamespaceOrType() -> void
@@ -41,8 +43,12 @@ Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Reversed() -> void
 Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Count.get -> int
 Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.GetEnumerator() -> Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.Enumerator
 Microsoft.CodeAnalysis.IOperation.OperationList.Reversed.ToImmutableArray() -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IOperation!>
+Microsoft.CodeAnalysis.IParameterSymbol.IsRefScoped.get -> bool
+Microsoft.CodeAnalysis.IParameterSymbol.IsValueScoped.get -> bool
 Microsoft.CodeAnalysis.SemanticModel.GetImportScopes(int position, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> System.Collections.Immutable.ImmutableArray<Microsoft.CodeAnalysis.IImportScope!>
 Microsoft.CodeAnalysis.ISymbol.Accept<TArgument, TResult>(Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>! visitor, TArgument argument) -> TResult
+Microsoft.CodeAnalysis.SymbolDisplayLocalOptions.IncludeScoped = 8 -> Microsoft.CodeAnalysis.SymbolDisplayLocalOptions
+Microsoft.CodeAnalysis.SymbolDisplayParameterOptions.IncludeScoped = 64 -> Microsoft.CodeAnalysis.SymbolDisplayParameterOptions
 Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>
 Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.SymbolVisitor() -> void
 override sealed Microsoft.CodeAnalysis.Diagnostic.Equals(object? obj) -> bool
@@ -82,5 +88,4 @@ virtual Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.VisitPointerTyp
 virtual Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.VisitProperty(Microsoft.CodeAnalysis.IPropertySymbol! symbol, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.VisitRangeVariable(Microsoft.CodeAnalysis.IRangeVariableSymbol! symbol, TArgument argument) -> TResult
 virtual Microsoft.CodeAnalysis.SymbolVisitor<TArgument, TResult>.VisitTypeParameter(Microsoft.CodeAnalysis.ITypeParameterSymbol! symbol, TArgument argument) -> TResult
-
 Microsoft.CodeAnalysis.Operations.BinaryOperatorKind.UnsignedRightShift = 25 -> Microsoft.CodeAnalysis.Operations.BinaryOperatorKind

src/Compilers/Core/Portable/SymbolDisplay/SymbolDisplayLocalOptions.cs

@@ -34,5 +34,10 @@ public enum SymbolDisplayLocalOptions
         /// Includes the <c>ref</c> keyword for ref-locals.
         /// </summary>
         IncludeRef = 1 << 2,
+
+        /// <summary>
+        /// Includes the <c>scoped</c> keyword.
+        /// </summary>
+        IncludeScoped = 1 << 3,
     }
 }

src/Compilers/Core/Portable/SymbolDisplay/SymbolDisplayParameterOptions.cs

@@ -54,5 +54,10 @@ public enum SymbolDisplayParameterOptions
         /// Includes square brackets around optional parameters.
         /// </summary>
         IncludeOptionalBrackets = 1 << 5,
+
+        /// <summary>
+        /// Includes the <c>scoped</c> keyword.
+        /// </summary>
+        IncludeScoped = 1 << 6,
     }
 }

src/Compilers/Core/Portable/Symbols/ILocalSymbol.cs

@@ -40,6 +40,16 @@ public interface ILocalSymbol : ISymbol
         /// </summary>
         RefKind RefKind { get; }
 
+        /// <summary>
+        /// Returns true if the ref local is scoped to the current method.
+        /// </summary>
+        bool IsRefScoped { get; }
+
+        /// <summary>
+        /// Returns true if the local value is scoped to the current method.
+        /// </summary>
+        bool IsValueScoped { get; }
+
         /// <summary>
         /// Returns false if the local variable wasn't declared as "const", or constant value was omitted or erroneous.
         /// True otherwise.

src/Compilers/Core/Portable/Symbols/IParameterSymbol.cs

@@ -62,6 +62,16 @@ public interface IParameterSymbol : ISymbol
         /// </summary>
         ImmutableArray<CustomModifier> RefCustomModifiers { get; }
 
+        /// <summary>
+        /// Returns true if the ref parameter is scoped to the current method.
+        /// </summary>
+        bool IsRefScoped { get; }
+
+        /// <summary>
+        /// Returns true if the parameter value is scoped to the current method.
+        /// </summary>
+        bool IsValueScoped { get; }
+
         /// <summary>
         /// Gets the ordinal position of the parameter. The first parameter has ordinal zero.
         /// The 'this' parameter ('Me' in Visual Basic) has ordinal -1.