Miscellaneous fixes (#17)

- More human friendly documentation formatting
- Skip noisy symbol relationships
- Add a few more test cases
- Update snapshot output format to not emit trailing whitespace
- Add comments to better explain some of the existing code

Author: olafurpg

ScipDotnet.Tests/SnapshotTests.cs

@@ -6,6 +6,7 @@
 using System.Text;
 using DiffPlex.DiffBuilder;
 using DiffPlex.DiffBuilder.Model;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Scip;
 using Index = Scip.Index;
 
@@ -106,7 +107,12 @@ private static string DiffStrings(string obtained, string expected)
 
             if (i > 0 && diff.Lines[i - 1].Type == ChangeType.Unchanged)
             {
-                sb.Append("  ").AppendLine(diff.Lines[i - 1].Text);
+                var text = diff.Lines[i - 1].Text;
+                if (text.Length > 0)
+                {
+                    sb.Append("  ");
+                }
+                sb.AppendLine(text);
             }
 
             switch (line.Type)
@@ -221,7 +227,7 @@ private string FormatDocument(Index index, Document document)
         for (var lineNumber = 0; lineNumber < lines.Length; lineNumber++)
         {
             var line = lines[lineNumber].Replace("\t", " ");
-            sb.Append("  ").AppendLine(line);
+            sb.Append(line.Length > 0 ? "  " : "").AppendLine(line);
             while (occurrenceIndex < occurrences.Count)
             {
                 var occurrence = occurrences[occurrenceIndex];

ScipDotnet/ScipCSharpSyntaxWalker.cs

@@ -1,6 +1,3 @@
-using System.Collections.Immutable;
-using System.Diagnostics.CodeAnalysis;
-using Google.Protobuf.Collections;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
@@ -22,31 +19,43 @@ public class ScipCSharpSyntaxWalker : CSharpSyntaxWalker
     private readonly Dictionary<ISymbol, ScipSymbol> _globals;
     private readonly Dictionary<ISymbol, ScipSymbol> _locals = new(SymbolEqualityComparer.Default);
 
+    // Custom formatting options to render symbol documentation. Feel free to tweak these parameters.
+    // The options were derived by multiple rounds of experimentation with the goal of striking a
+    // balance between showing detailed/accurate information without using too verbose syntax.
     private readonly SymbolDisplayFormat _format = new(
         globalNamespaceStyle: SymbolDisplayGlobalNamespaceStyle.OmittedAsContaining,
-        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameAndContainingTypesAndNamespaces,
+        typeQualificationStyle: SymbolDisplayTypeQualificationStyle.NameOnly,
         genericsOptions: SymbolDisplayGenericsOptions.IncludeTypeParameters |
                          SymbolDisplayGenericsOptions.IncludeVariance |
                          SymbolDisplayGenericsOptions.IncludeTypeConstraints,
-        memberOptions: SymbolDisplayMemberOptions.IncludeAccessibility | SymbolDisplayMemberOptions.IncludeModifiers |
-                       SymbolDisplayMemberOptions.IncludeParameters | SymbolDisplayMemberOptions.IncludeRef |
-                       SymbolDisplayMemberOptions.IncludeType | SymbolDisplayMemberOptions.IncludeConstantValue |
+        memberOptions: SymbolDisplayMemberOptions.IncludeAccessibility |
+                       SymbolDisplayMemberOptions.IncludeModifiers |
+                       SymbolDisplayMemberOptions.IncludeParameters |
+                       SymbolDisplayMemberOptions.IncludeRef |
+                       SymbolDisplayMemberOptions.IncludeType |
+                       SymbolDisplayMemberOptions.IncludeConstantValue |
                        SymbolDisplayMemberOptions.IncludeContainingType |
                        SymbolDisplayMemberOptions.IncludeExplicitInterface,
         delegateStyle: SymbolDisplayDelegateStyle.NameAndSignature,
         extensionMethodStyle: SymbolDisplayExtensionMethodStyle.InstanceMethod,
-        parameterOptions: SymbolDisplayParameterOptions.IncludeType | SymbolDisplayParameterOptions.IncludeName |
+        parameterOptions: SymbolDisplayParameterOptions.IncludeType |
+                          SymbolDisplayParameterOptions.IncludeName |
                           SymbolDisplayParameterOptions.IncludeDefaultValue |
                           SymbolDisplayParameterOptions.IncludeExtensionThis |
                           SymbolDisplayParameterOptions.IncludeOptionalBrackets |
                           SymbolDisplayParameterOptions.IncludeParamsRefOut,
         propertyStyle: SymbolDisplayPropertyStyle.ShowReadWriteDescriptor,
-        localOptions: SymbolDisplayLocalOptions.IncludeType | SymbolDisplayLocalOptions.IncludeRef |
+        localOptions: SymbolDisplayLocalOptions.IncludeType |
+                      SymbolDisplayLocalOptions.IncludeRef |
                       SymbolDisplayLocalOptions.IncludeConstantValue,
-        kindOptions: SymbolDisplayKindOptions.IncludeTypeKeyword | SymbolDisplayKindOptions.IncludeMemberKeyword |
+        kindOptions: SymbolDisplayKindOptions.IncludeTypeKeyword |
+                     SymbolDisplayKindOptions.IncludeMemberKeyword |
                      SymbolDisplayKindOptions.IncludeNamespaceKeyword,
         miscellaneousOptions: SymbolDisplayMiscellaneousOptions.AllowDefaultLiteral |
-                              SymbolDisplayMiscellaneousOptions.ExpandNullable
+                              SymbolDisplayMiscellaneousOptions.UseSpecialTypes |
+                              SymbolDisplayMiscellaneousOptions.UseAsterisksInMultiDimensionalArrays |
+                              SymbolDisplayMiscellaneousOptions.IncludeNullableReferenceTypeModifier |
+                              SymbolDisplayMiscellaneousOptions.EscapeKeywordIdentifiers
     );
 
     public ScipCSharpSyntaxWalker(
@@ -174,7 +183,6 @@ public override void VisitParameter(ParameterSyntax node)
     //------------------
 
 
-
     private ScipSymbol CreateScipSymbol(ISymbol? sym)
     {
         if (sym == null)
@@ -310,6 +318,22 @@ private static string MethodDisambiguator(ISymbol sym)
         return "";
     }
 
+    private readonly string[] _isIgnoredRelationshipSymbol =
+    {
+        " System/Object#",
+        " System/Enum#",
+        " System/ValueType#",
+    };
+
+    // Returns true if this symbol should not be emitted as a SymbolInformation relationship symbol.
+    // The reason we ignore these symbols is because they appear automatically for a large number of
+    // symbols putting pressure on our backend to index the inverted index. It's not particularly useful anyways
+    // to query all the implementations of something like System/Object#.
+    private bool IsIgnoredRelationshipSymbol(string symbol)
+    {
+        return _isIgnoredRelationshipSymbol.Any(symbol.EndsWith);
+    }
+
 
     private void VisitOccurrence(ISymbol? symbol, Location location, bool isDefinition)
     {
@@ -361,19 +385,31 @@ private void VisitOccurrence(ISymbol? symbol, Location location, bool isDefiniti
                     var baseType = namedTypeSymbol.BaseType;
                     while (baseType != null)
                     {
+                        var baseTypeSymbol = CreateScipSymbol(baseType).Value;
+                        if (IsIgnoredRelationshipSymbol(baseTypeSymbol))
+                        {
+                            break;
+                        }
+
                         info.Relationships.Add(new Relationship
                         {
-                            Symbol = CreateScipSymbol(baseType).Value,
+                            Symbol = baseTypeSymbol,
                             IsImplementation = true
                         });
                         baseType = baseType.BaseType;
                     }
 
                     foreach (var interfaceSymbol in namedTypeSymbol.AllInterfaces)
                     {
+                        var interfaceSymbolSymbol = CreateScipSymbol(interfaceSymbol).Value;
+                        if (IsIgnoredRelationshipSymbol(interfaceSymbolSymbol))
+                        {
+                            continue;
+                        }
+
                         info.Relationships.Add(new Relationship
                         {
-                            Symbol = CreateScipSymbol(interfaceSymbol).Value,
+                            Symbol = interfaceSymbolSymbol,
                             IsImplementation = true
                         });
                     }
@@ -448,6 +484,10 @@ private static IEnumerable<int> LocationToRange(Location location)
 
     private static bool IsLocalSymbol(ISymbol sym)
     {
-        return sym.Kind == SymbolKind.Local || (sym.Kind != SymbolKind.Namespace && sym.Name.Equals(""));
+        return sym.Kind == SymbolKind.Local ||
+               // Anonymous classes/methods have empty names and can not be accessed outside their file.
+               // The "global namespace" (parent of all namespaces) also has an empty name and should not
+               // be treated as a local variable.
+               (sym.Name.Equals("") && sym.Kind != SymbolKind.Namespace);
     }
 }

snapshots/input/syntax/Main/Enums.cs

@@ -1,5 +1,8 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace Main;
 
+[SuppressMessage("ReSharper", "all")]
 public class Enums
 {
     enum EnumWithIntValues

snapshots/input/syntax/Main/Literals.cs

@@ -1,5 +1,8 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace Main;
 
+[SuppressMessage("ReSharper", "all")]
 public class Literals
 {
     string Interpolation()

snapshots/input/syntax/Main/Preprocessors.cs

@@ -1,5 +1,8 @@
+using System.Diagnostics.CodeAnalysis;
+
 namespace Main;
 
+[SuppressMessage("ReSharper", "all")]
 public class Preprocessors
 {
     string OS()

snapshots/input/syntax/Main/Records.cs

@@ -42,6 +42,12 @@ public Person(string FirstName) : this(FirstName, FirstName)
 
     record Teacher(string FirstName, string LastName, string Subject) : Person(FirstName, LastName), I1, I2;
 
+    void UsingRecords()
+    {
+        var person = new Person("a", "b");
+        var teacher = new Teacher("a", "b", "c");
+    }
+
     record I3<T>;
 
     record Teacher2() : I3<Person>(), I1;