Omnisharp VS Code Issue 1814 Fix

src/OmniSharp.Roslyn.CSharp/Services/Signatures/InvocationContext.cs

@@ -1,13 +1,36 @@
+using System.Collections.Generic;
+using System.Linq;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
+
 namespace OmniSharp.Roslyn.CSharp.Services.Signatures
 {
     internal class InvocationContext
     {
-        public SemanticModel SemanticModel { get; set; }
-        public int Position { get; set; }
-        public SyntaxNode Receiver { get; set; }
-        public ArgumentListSyntax ArgumentList { get; set; }
-    }
+        public SemanticModel SemanticModel { get; }
+        public int Position { get; }
+        public SyntaxNode Receiver { get; }
+        public IEnumerable<TypeInfo> ArgumentTypes { get; }
+        public IEnumerable<SyntaxToken> Separators { get; }
+
+        public InvocationContext(SemanticModel semModel, int position, SyntaxNode receiver, ArgumentListSyntax argList)
+        {
+            SemanticModel = semModel;
+            Position = position;
+            Receiver = receiver;
+            ArgumentTypes = argList.Arguments.Select(argument => semModel.GetTypeInfo(argument.Expression));
+            Separators = argList.Arguments.GetSeparators();
+        }
+
+        public InvocationContext(SemanticModel semModel, int position, SyntaxNode receiver, AttributeArgumentListSyntax argList)
+        {
+            SemanticModel = semModel;
+            Position = position;
+            Receiver = receiver;
+            ArgumentTypes = argList.Arguments.Select(argument => semModel.GetTypeInfo(argument.Expression));
+            Separators = argList.Arguments.GetSeparators();
+        }
+    }  
 }
+

src/OmniSharp.Roslyn.CSharp/Services/Signatures/SignatureHelpService.cs

@@ -42,7 +42,7 @@ public async Task<SignatureHelpResponse> Handle(SignatureHelpRequest request)
             var response = new SignatureHelpResponse();
 
             // define active parameter by position
-            foreach (var comma in invocations.First().ArgumentList.Arguments.GetSeparators())
+            foreach (var comma in invocations.First().Separators)
             {
                 if (comma.Span.Start > invocations.First().Position)
                 {
@@ -58,9 +58,7 @@ public async Task<SignatureHelpResponse> Handle(SignatureHelpRequest request)
 
             foreach (var invocation in invocations)
             {
-                var types = invocation.ArgumentList.Arguments
-                    .Select(argument => invocation.SemanticModel.GetTypeInfo(argument.Expression));
-
+                var types = invocation.ArgumentTypes;
                 foreach (var methodOverload in GetMethodOverloads(invocation.SemanticModel, invocation.Receiver))
                 {
                     var signature = BuildSignature(methodOverload);
@@ -93,28 +91,22 @@ private async Task<InvocationContext> GetInvocation(Document document, Request r
             // Walk up until we find a node that we're interested in.
             while (node != null)
             {
-                var invocation = node as InvocationExpressionSyntax;
-                if (invocation != null && invocation.ArgumentList.Span.Contains(position))
+                if (node is InvocationExpressionSyntax invocation && invocation.ArgumentList.Span.Contains(position))
                 {
-                    return new InvocationContext()
-                    {
-                        SemanticModel = await document.GetSemanticModelAsync(),
-                        Position = position,
-                        Receiver = invocation.Expression,
-                        ArgumentList = invocation.ArgumentList
-                    };
+                    var semanticModel = await document.GetSemanticModelAsync();
+                    return new InvocationContext(semanticModel, position, invocation.Expression, invocation.ArgumentList);
                 }
 
-                var objectCreation = node as ObjectCreationExpressionSyntax;
-                if (objectCreation != null && objectCreation.ArgumentList.Span.Contains(position))
+                if (node is ObjectCreationExpressionSyntax objectCreation && objectCreation.ArgumentList.Span.Contains(position))
                 {
-                    return new InvocationContext()
-                    {
-                        SemanticModel = await document.GetSemanticModelAsync(),
-                        Position = position,
-                        Receiver = objectCreation,
-                        ArgumentList = objectCreation.ArgumentList
-                    };
+                    var semanticModel = await document.GetSemanticModelAsync();
+                    return new InvocationContext(semanticModel, position, objectCreation, objectCreation.ArgumentList);
+                }
+
+                if (node is AttributeSyntax attributeSyntax && attributeSyntax.ArgumentList.Span.Contains(position))
+                {
+                    var semanticModel = await document.GetSemanticModelAsync();
+                    return new InvocationContext(semanticModel, position, attributeSyntax, attributeSyntax.ArgumentList);
                 }
 
                 node = node.Parent;

tests/OmniSharp.Roslyn.CSharp.Tests/SignatureHelpFacts.cs

@@ -115,7 +115,7 @@ public async Task TestForParameterLabels()
     public static void Main(){
         Foo($$);
     }
-    pubic static Foo(bool b, int n = 1234)
+    public static Foo(bool b, int n = 1234)
     {
     }
 }";
@@ -152,6 +152,112 @@ private int Foo(int one, int two, int three)
             Assert.Equal(0, actual.ActiveParameter);
         }
 
+        [Fact]
+        public async Task SignatureHelpforAttributeCtorSingleParam()
+        {
+            const string source =
+@"using System;
+[MyTest($$)]
+public class TestClass 
+{
+    public static void Main()
+    {
+    }
+}
+public class MyTestAttribute : Attribute 
+{
+    public MyTestAttribute(int value)
+    {
+    }
+}";
+            var actual = await GetSignatureHelp(source);    
+            Assert.Equal(0, actual.ActiveParameter);
+
+            var signature = actual.Signatures.ElementAt(0);
+            Assert.Single(signature.Parameters);
+            Assert.Equal("value", signature.Parameters.ElementAt(0).Name);
+            Assert.Equal("int value", signature.Parameters.ElementAt(0).Label);
+        }
+
+        [Fact]
+        public async Task SignatureHelpforAttributeCtorTestParameterLabels()
+        {
+            const string source =
+@"using System;
+[MyTest($$)]
+public class TestClass 
+{
+    public static void Main()
+    {
+    }
+}
+public class MyTestAttribute : Attribute 
+{
+    public MyTestAttribute(int value1,double value2)
+    {
+    }
+}
+";
+            var actual = await GetSignatureHelp(source);
+            Assert.Equal(0, actual.ActiveParameter);
+
+            var signature = actual.Signatures.ElementAt(0);
+            Assert.Equal(2, signature.Parameters.Count());
+            Assert.Equal("value1", signature.Parameters.ElementAt(0).Name);
+            Assert.Equal("int value1", signature.Parameters.ElementAt(0).Label);
+            Assert.Equal("value2", signature.Parameters.ElementAt(1).Name);
+            Assert.Equal("double value2", signature.Parameters.ElementAt(1).Label);
+        }
+
+        [Fact]
+        public async Task SignatureHelpforAttributeCtorActiveParamBasedOnComma()
+        {
+            const string source =
+@"using System;
+[MyTest(2,$$)]
+public class TestClass 
+{
+    public static void Main()
+    {
+    }
+}
+public class MyTestAttribute : Attribute 
+{
+    public MyTestAttribute(int value1,double value2)
+    {
+    }
+}
+";
+            var actual = await GetSignatureHelp(source);
+            Assert.Equal(1, actual.ActiveParameter);
+        }
+
+        [Fact]
+        public async Task SignatureHelpforAttributeCtorNoParam()
+        {
+            const string source =
+@"using System;
+[MyTest($$)]
+public class TestClass 
+{
+    public static void Main()
+    {
+    }
+}
+public class MyTestAttribute : Attribute 
+{
+    public MyTestAttribute()
+    {
+    }
+}";
+            var actual = await GetSignatureHelp(source);
+            Assert.Single(actual.Signatures);
+            Assert.Equal(0, actual.ActiveParameter);
+            Assert.Equal(0, actual.ActiveSignature);
+            Assert.Equal("MyTestAttribute", actual.Signatures.ElementAt(0).Name);
+            Assert.Empty(actual.Signatures.ElementAt(0).Parameters);
+        }
+
         [Fact]
         public async Task ActiveParameterIsBasedOnComma2()
         {
@@ -323,7 +429,7 @@ private int Foo(string m, int n)
         }
 
         [Fact]
-        public async Task SigantureHelpForCtor()
+        public async Task SignatureHelpForCtor()
         {
             const string source =
 @"class Program
@@ -348,7 +454,7 @@ public Program(Program p)
         }
 
         [Fact]
-        public async Task SigantureHelpForCtorWithOverloads()
+        public async Task SignatureHelpForCtorWithOverloads()
         {
             const string source =
 @"class Program