Implement find all references to preprocessing symbols (#66425)

Author: CyrusNajmabadi

src/Compilers/CSharp/Portable/Compilation/CSharpCompilation.cs

@@ -334,6 +334,11 @@ protected override INamespaceSymbol CommonCreateErrorNamespaceSymbol(INamespaceS
                        name).GetPublicSymbol();
         }
 
+        protected override IPreprocessingSymbol CommonCreatePreprocessingSymbol(string name)
+        {
+            return new Symbols.PublicModel.PreprocessingSymbol(name);
+        }
+
         #region Constructors and Factories
 
         private static readonly CSharpCompilationOptions s_defaultOptions = new CSharpCompilationOptions(OutputKind.ConsoleApplication);

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

@@ -341,6 +341,13 @@ public override void VisitAlias(IAliasSymbol symbol)
             }
         }
 
+        internal override void VisitPreprocessing(IPreprocessingSymbol symbol)
+        {
+            // Currently using 'Text' part kind as there is no kind specific to preprocessing symbols.
+            var part = new SymbolDisplayPart(SymbolDisplayPartKind.Text, symbol, symbol.Name);
+            Builder.Add(part);
+        }
+
         protected override void AddSpace()
         {
             Builder.Add(CreatePart(SymbolDisplayPartKind.Space, null, " "));

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

@@ -65,11 +65,11 @@ bool ISymbol.Equals(ISymbol? other, CodeAnalysis.SymbolEqualityComparer equality
 
         Accessibility ISymbol.DeclaredAccessibility => Accessibility.NotApplicable;
 
-        void ISymbol.Accept(SymbolVisitor visitor) => throw new System.NotSupportedException();
+        void ISymbol.Accept(SymbolVisitor visitor) => visitor.VisitPreprocessing(this);
 
-        TResult ISymbol.Accept<TResult>(SymbolVisitor<TResult> visitor) => throw new System.NotSupportedException();
+        TResult ISymbol.Accept<TResult>(SymbolVisitor<TResult> visitor) => visitor.VisitPreprocessing(this)!;
 
-        TResult ISymbol.Accept<TArgument, TResult>(SymbolVisitor<TArgument, TResult> visitor, TArgument argument) => throw new System.NotSupportedException();
+        TResult ISymbol.Accept<TArgument, TResult>(SymbolVisitor<TArgument, TResult> visitor, TArgument argument) => visitor.VisitPreprocessing(this, argument);
 
         string? ISymbol.GetDocumentationCommentId() => null;
 

src/Compilers/CSharp/Test/Symbol/Compilation/SemanticModelAPITests.cs

@@ -4745,6 +4745,24 @@ class C(out Type[M2(out object y)])
             Assert.Null(model.GetAliasInfo(identifier));
         }
 
+        [Fact]
+        public void CommonPreprocessingSymbolProperties()
+        {
+            var text = """
+                #if NET5_0_OR_GREATER
+                #endif
+                """;
+            var compilation = CreateCompilation(text);
+
+            var tree = compilation.SyntaxTrees.Single();
+            var identifier = tree.GetRoot().DescendantNodes(descendIntoTrivia: true).OfType<IdentifierNameSyntax>().First();
+            var model = compilation.GetSemanticModel(tree);
+            var preprocessingSymbol = model.GetPreprocessingSymbolInfo(identifier).Symbol;
+            Assert.NotNull(preprocessingSymbol);
+            Assert.Equal("NET5_0_OR_GREATER", preprocessingSymbol.Name);
+            Assert.True(preprocessingSymbol.CanBeReferencedByName);
+        }
+
         #region "regression helper"
         private void Regression(string text)
         {

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

@@ -8837,5 +8837,37 @@ void M()
                 SymbolDisplayPartKind.ParameterName,
                 SymbolDisplayPartKind.Punctuation);
         }
+
+        [Fact, WorkItem(66009, "https://github.com/dotnet/roslyn/issues/66009")]
+        public void PreprocessingSymbol()
+        {
+            var source = """
+                #if NET5_0_OR_GREATER
+                #endif
+                """;
+
+            var comp = CreateCompilation(source);
+            var tree = comp.SyntaxTrees.First();
+            var model = comp.GetSemanticModel(tree);
+            var preprocessingNameSyntax = tree.GetRoot().DescendantNodes(descendIntoTrivia: true)
+                .OfType<IdentifierNameSyntax>().First();
+            var preprocessingSymbolInfo = model.GetPreprocessingSymbolInfo(preprocessingNameSyntax);
+            var preprocessingSymbol = preprocessingSymbolInfo.Symbol;
+
+            var format = new SymbolDisplayFormat(
+                 memberOptions: SymbolDisplayMemberOptions.IncludeParameters,
+                 parameterOptions: SymbolDisplayParameterOptions.IncludeType |
+                                   SymbolDisplayParameterOptions.IncludeName |
+                                   SymbolDisplayParameterOptions.IncludeDefaultValue);
+
+            Assert.Equal("NET5_0_OR_GREATER", preprocessingSymbol.ToDisplayString(format));
+
+            var displayParts = preprocessingSymbol.ToDisplayParts(format);
+            AssertEx.Equal(
+                expected: [
+                    new SymbolDisplayPart(SymbolDisplayPartKind.Text, preprocessingSymbol, "NET5_0_OR_GREATER")
+                ],
+                actual: displayParts);
+        }
     }
 }

src/Compilers/Core/Portable/Compilation/Compilation.cs

@@ -379,6 +379,14 @@ public INamespaceSymbol CreateErrorNamespaceSymbol(INamespaceSymbol container, s
 
         protected abstract INamespaceSymbol CommonCreateErrorNamespaceSymbol(INamespaceSymbol container, string name);
 
+        /// <summary>
+        /// Returns a new IPreprocessingSymbol representing a preprocessing symbol with the given name.
+        /// </summary>
+        public IPreprocessingSymbol CreatePreprocessingSymbol(string name)
+            => CommonCreatePreprocessingSymbol(name ?? throw new ArgumentNullException(nameof(name)));
+
+        protected abstract IPreprocessingSymbol CommonCreatePreprocessingSymbol(string name);
+
         #region Name
 
         internal const string UnspecifiedModuleAssemblyName = "?";

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

@@ -19,6 +19,7 @@ Microsoft.CodeAnalysis.ITypeParameterSymbol.AllowsRefLikeType.get -> bool
 Microsoft.CodeAnalysis.RuntimeCapability.ByRefLikeGenerics = 8 -> Microsoft.CodeAnalysis.RuntimeCapability
 static Microsoft.CodeAnalysis.GeneratorExtensions.AsIncrementalGenerator(this Microsoft.CodeAnalysis.ISourceGenerator! sourceGenerator) -> Microsoft.CodeAnalysis.IIncrementalGenerator!
 static Microsoft.CodeAnalysis.GeneratorExtensions.GetGeneratorType(this Microsoft.CodeAnalysis.IIncrementalGenerator! generator) -> System.Type!
+Microsoft.CodeAnalysis.Compilation.CreatePreprocessingSymbol(string! name) -> Microsoft.CodeAnalysis.IPreprocessingSymbol!
 [RSEXPERIMENTAL004]Microsoft.CodeAnalysis.HostOutputProductionContext
 [RSEXPERIMENTAL004]Microsoft.CodeAnalysis.HostOutputProductionContext.AddOutput(string! name, object! value) -> void
 [RSEXPERIMENTAL004]Microsoft.CodeAnalysis.HostOutputProductionContext.CancellationToken.get -> System.Threading.CancellationToken

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

@@ -109,5 +109,10 @@ public virtual void VisitTypeParameter(ITypeParameterSymbol symbol)
         {
             DefaultVisit(symbol);
         }
+
+        internal virtual void VisitPreprocessing(IPreprocessingSymbol symbol)
+        {
+            DefaultVisit(symbol);
+        }
     }
 }

src/Compilers/Core/Portable/Symbols/SymbolVisitor`1.cs

@@ -112,5 +112,10 @@ public abstract class SymbolVisitor<TResult>
         {
             return DefaultVisit(symbol);
         }
+
+        internal virtual TResult? VisitPreprocessing(IPreprocessingSymbol symbol)
+        {
+            return DefaultVisit(symbol);
+        }
     }
 }

src/Compilers/Core/Portable/Symbols/SymbolVisitor`2.cs

@@ -117,5 +117,10 @@ public virtual TResult VisitTypeParameter(ITypeParameterSymbol symbol, TArgument
         {
             return DefaultVisit(symbol, argument);
         }
+
+        internal virtual TResult VisitPreprocessing(IPreprocessingSymbol symbol, TArgument argument)
+        {
+            return DefaultVisit(symbol, argument);
+        }
     }
 }