Generics inlay hints (#427)

* Script fixes

* Exposed more of the symbols API

* Update package-lock.json

* Added config on VSC side

* Added inlay hints on langserver side

scripts/install_langserver.ps1

@@ -6,7 +6,7 @@
 
 $ErrorActionPreference = "Stop"
 Push-Location $PSScriptRoot
-dotnet pack ../src/Draco.LanguageServer --output .
+dotnet pack ../src/Draco.LanguageServer --configuration Debug --output .
 if ((dotnet tool list --global) -match "Draco.LanguageServer") {
     dotnet tool uninstall --global Draco.LanguageServer
 }

scripts/install_vscext.ps1

@@ -9,7 +9,7 @@ $ErrorActionPreference = "Stop"
 Push-Location $PSScriptRoot
 cd ../src/Draco.Extension.VsCode
 npm i
-vsce package --skip-license
+echo 'y' | vsce package
 $vsixFile = Get-ChildItem -Filter "*.vsix" | Select-Object -First 1
 code --install-extension $vsixFile --force
 Pop-Location

src/Draco.Compiler/Api/Semantics/Symbol.cs

@@ -72,6 +72,11 @@ public interface ISymbol : IEquatable<ISymbol>
     /// The generic definition of this symbol, in case this is a generic instance.
     /// </summary>
     public ISymbol? GenericDefinition { get; }
+
+    /// <summary>
+    /// The generic arguments of this symbol, in case this is a generic instance.
+    /// </summary>
+    public IEnumerable<ITypeSymbol> GenericArguments { get; }
 }
 
 /// <summary>
@@ -210,6 +215,7 @@ internal abstract class SymbolBase(Symbol symbol) : ISymbol
     public bool IsGenericDefinition => this.Symbol.IsGenericDefinition;
     public bool IsGenericInstance => this.Symbol.IsGenericInstance;
     public ISymbol? GenericDefinition => this.Symbol.GenericDefinition?.ToApiSymbol();
+    public IEnumerable<ITypeSymbol> GenericArguments => this.Symbol.GenericArguments.Select(a => a.ToApiSymbol());
 
     public bool Equals(ISymbol? other) => other is SymbolBase o
                                        && ReferenceEquals(this.Symbol, o.Symbol);

src/Draco.Compiler/Internal/Symbols/TypeVariable.cs

@@ -45,6 +45,12 @@ public override TypeSymbol Substitution
     private TypeSymbol? substitution;
     private readonly int index = index;
 
+    public override Api.Semantics.ITypeSymbol ToApiSymbol()
+    {
+        if (this.substitution is null) throw new InvalidOperationException("type variable not substituted");
+        return this.Substitution.ToApiSymbol();
+    }
+
     public override string ToString() => this.Substitution switch
     {
         TypeVariable typeVar => $"{StringUtils.IndexToExcelColumnName(typeVar.index)}'",

src/Draco.Extension.VsCode/package.json

@@ -129,6 +129,11 @@
           "type": "boolean",
           "default": true,
           "description": "Show variable type hints."
+        },
+        "draco.inlayHints.genericArguments": {
+          "type": "boolean",
+          "default": true,
+          "description": "Show generic argument type hints."
         }
       }
     },

src/Draco.LanguageServer/Capabilities/InlayHint.cs

@@ -14,7 +14,7 @@ internal sealed partial class DracoLanguageServer : IInlayHint
 {
     public InlayHintRegistrationOptions InlayHintRegistrationOptions => new()
     {
-        DocumentSelector = DocumentSelector,
+        DocumentSelector = this.DocumentSelector,
     };
 
     public Task<IList<InlayHint>> InlayHintAsync(InlayHintParams param, CancellationToken cancellationToken)
@@ -33,7 +33,9 @@ public Task<IList<InlayHint>> InlayHintAsync(InlayHintParams param, Cancellation
         var inlayHints = new List<InlayHint>();
         foreach (var node in syntaxTree.TraverseSubtreesIntersectingRange(range))
         {
-            if (config.VariableTypes && node is VariableDeclarationSyntax varDecl)
+            switch (node)
+            {
+            case VariableDeclarationSyntax varDecl when config.VariableTypes:
             {
                 // Type is already specified by user
                 if (varDecl.Type is not null) continue;
@@ -50,8 +52,9 @@ public Task<IList<InlayHint>> InlayHintAsync(InlayHintParams param, Cancellation
                     Kind = InlayHintKind.Type,
                     Label = $": {varType}",
                 });
+                break;
             }
-            else if (config.VariableTypes && node is ForExpressionSyntax @for)
+            case ForExpressionSyntax @for when config.ParameterNames:
             {
                 if (@for.ElementType is not null) continue;
 
@@ -67,25 +70,50 @@ public Task<IList<InlayHint>> InlayHintAsync(InlayHintParams param, Cancellation
                     Kind = InlayHintKind.Type,
                     Label = $": {varType}",
                 });
+                break;
             }
-            else if (config.ParameterNames && node is CallExpressionSyntax call)
+            case CallExpressionSyntax call:
             {
-                var symbol = semanticModel.GetReferencedSymbol(call.Function);
-                if (symbol is not IFunctionSymbol funcSymbol) continue;
+                if (config.ParameterNames)
+                {
+                    var symbol = semanticModel.GetReferencedSymbol(call.Function);
+                    if (symbol is not IFunctionSymbol funcSymbol) continue;
 
-                foreach (var (argSyntax, paramSymbol) in call.ArgumentList.Values.Zip(funcSymbol.Parameters))
+                    foreach (var (argSyntax, paramSymbol) in call.ArgumentList.Values.Zip(funcSymbol.Parameters))
+                    {
+                        var position = argSyntax.Range.Start;
+                        var name = paramSymbol.Name;
+                        if (string.IsNullOrWhiteSpace(name)) continue;
+
+                        inlayHints.Add(new InlayHint()
+                        {
+                            Position = Translator.ToLsp(position),
+                            Kind = InlayHintKind.Parameter,
+                            Label = $"{name} = ",
+                        });
+                    }
+                }
+                if (config.GenericArguments)
                 {
-                    var position = argSyntax.Range.Start;
-                    var name = paramSymbol.Name;
-                    if (string.IsNullOrWhiteSpace(name)) continue;
+                    var symbol = semanticModel.GetReferencedSymbol(call.Function);
+                    if (symbol is not IFunctionSymbol funcSymbol) continue;
+                    // Not even a generic function
+                    if (!symbol.IsGenericInstance) continue;
+                    // See, if the syntax provided generic arguments
+                    if (call.Function is GenericExpressionSyntax) continue;
+                    // It did not, we can provide hints
+                    var position = call.Function.Range.End;
+                    var genericArgs = string.Join(", ", funcSymbol.GenericArguments.Select(arg => arg.Name));
 
                     inlayHints.Add(new InlayHint()
                     {
                         Position = Translator.ToLsp(position),
-                        Kind = InlayHintKind.Parameter,
-                        Label = $"{name} = ",
+                        Kind = InlayHintKind.Type,
+                        Label = $"<{genericArgs}>",
                     });
                 }
+                break;
+            }
             }
         }
 

src/Draco.LanguageServer/Configurations/InlayHintsConfiguration.cs

@@ -4,4 +4,5 @@ internal sealed class InlayHintsConfiguration
 {
     public bool ParameterNames { get; set; }
     public bool VariableTypes { get; set; }
+    public bool GenericArguments { get; set; }
 }

src/Draco.LanguageServer/DracoConfigurationRepository.cs

@@ -19,5 +19,6 @@ public async Task UpdateConfigurationAsync()
 
         this.InlayHints.ParameterNames = cfg[0].GetProperty("parameterNames"u8).GetBoolean();
         this.InlayHints.VariableTypes = cfg[0].GetProperty("variableTypes"u8).GetBoolean();
+        this.InlayHints.GenericArguments = cfg[0].GetProperty("genericArguments"u8).GetBoolean();
     }
 }