Omnisharp VS Code Issue 1814 Fix

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

@@ -1,13 +1,21 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using System.Collections.Generic;
 
 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 IEnumerable<TypeInfo> ArgumentTypes { get; set; }
+        public IEnumerable<SyntaxToken> Separators { get; set; } 
     }
+
+
+
 }
+

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,8 +58,9 @@ 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))
                 {
@@ -96,27 +97,43 @@ private async Task<InvocationContext> GetInvocation(Document document, Request r
                 var invocation = node as InvocationExpressionSyntax;
                 if (invocation != null && invocation.ArgumentList.Span.Contains(position))
                 {
+                    var i = await document.GetSemanticModelAsync();
                     return new InvocationContext()
                     {
                         SemanticModel = await document.GetSemanticModelAsync(),
                         Position = position,
                         Receiver = invocation.Expression,
-                        ArgumentList = invocation.ArgumentList
+                        ArgumentTypes = invocation.ArgumentList.Arguments.Select(argument => i.GetTypeInfo(argument.Expression)),
+                        Separators = invocation.ArgumentList.Arguments.GetSeparators()
                     };
                 }
-
                 var objectCreation = node as ObjectCreationExpressionSyntax;
                 if (objectCreation != null && objectCreation.ArgumentList.Span.Contains(position))
                 {
+                    var i = await document.GetSemanticModelAsync();
                     return new InvocationContext()
                     {
-                        SemanticModel = await document.GetSemanticModelAsync(),
+                        SemanticModel = i,
                         Position = position,
                         Receiver = objectCreation,
-                        ArgumentList = objectCreation.ArgumentList
+                        ArgumentTypes = objectCreation.ArgumentList.Arguments.Select(argument => i.GetTypeInfo(argument.Expression)),
+                        Separators = objectCreation.ArgumentList.Arguments.GetSeparators()
                     };
                 }
 
+                var attributeSyntax = node as AttributeSyntax;
+                if (attributeSyntax != null && attributeSyntax.ArgumentList.Span.Contains(position))
+                {
+                    var i = await document.GetSemanticModelAsync();
+                    return new InvocationContext()
+                    {
+                        SemanticModel = i,
+                        Position = position,
+                        Receiver = attributeSyntax,
+                        ArgumentTypes = attributeSyntax.ArgumentList.Arguments.Select(argument => i.GetTypeInfo(argument.Expression)),
+                        Separators = attributeSyntax.ArgumentList.Arguments.GetSeparators()
+                    };
+                }
                 node = node.Parent;
             }
 

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

@@ -153,6 +153,7 @@ private async Task<IEnumerable<ISymbol>> FindImplementationsAsync(string code, s
             }
         }
 
+
         private async Task<IEnumerable<ISymbol>> SymbolsFromQuickFixesAsync(OmniSharpWorkspace workspace, IEnumerable<QuickFix> quickFixes)
         {
             var symbols = new List<ISymbol>();

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,42 @@ private int Foo(int one, int two, int three)
             Assert.Equal(0, actual.ActiveParameter);
         }
 
+        [Fact]
+        public async Task AttributeConstructorSignatureHelp()
+        {
+            // 1st position, a
+            const string source =
+                @"using System;
+
+        namespace New_folder
+        {
+            using System;
+        [MyTest($$)]
+        public class TestClass {
+            int value;
+            public static void Main(){
+            }
+            void TestMethod(int value){
+                this.value = value;
+            }
+            public class MyTestAttribute : Attribute {
+            int value;
+            public MyTestAttribute(int value)
+            {
+                this.value =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 ActiveParameterIsBasedOnComma2()
         {