Open generic type arguments cannot be inferred from the usage

Question

In this question, when mentioning the compiler, I'm actually referring to the Roslyn compiler. The problem arises when using IntelliSense, which is presumed to be the same compiler.

For demonstration purposes and completeness, the following classes are used (using Visual Studio 2015 with C# 6.0 and .NET 4.6.1):

public class A
{
    public IEnumerable<B> B { get; set; }
}
public class B
{
    public IEnumerable<C> C { get; set; }
}
public class C { }
public class Helper<T> { }

Behold the following extension method:

public static void FooBar<T1, T2>(
    this Helper<IEnumerable<T1>> helper,
    Expression<Func<T1, IEnumerable<T2>>> expression) { ... }

The compiler is able to infer it while consuming like this:

Helper<IEnumerable<B>> helper = ...;
helper.FooBar(l => l.C); //T1 is B and T2 is C

Also behold this overloaded extension method:

public static void FooBar<T1, T2, T3>(
    this Helper<T1> helper,
    Expression<Func<T1, IEnumerable<T2>>> expression1,
    Expression<Func<T2, IEnumerable<T3>>> expression2) { ... }

The compiler is NOT able to infer T1 when typing it like this:

Helper<A> helper = ...;
helper.FooBar(l => l. //compiler/IntelliSense cannot infer that T1 is A

This screenshot example will describe more of what I mean with not able to infer:

Also I'm getting this error message when hovering over the extension method with my mouse (I've replaced the < and > characters with [ and ] respectively, because StackOverflow cannot format those in a quote):

The type arguments for method 'FooBar[T1,T2](this Helper[IEnumerable[T1]], Expression[Func[T1, IEnumerable[T2]]])' cannot be inferred from the usage. Try specifying the type arguments explicitly.

But when completing it manually like this:

helper.FooBar(l => l.B, l => l.C); //compiler infers that T1 is A, T2 is B and T3 is C

the compiler is happy.

Why can't the compiler/IntelliSense (or the autocomplete feature of Visual Studio) figure out T1 and wants me to specify the type arguments explicitly when I start typing?

Note that if I omit IEnumerable<> everywhere in my examples, the compiler can happily infer everything while typing.
The compiler is also happy after you manually type in l => l.B. It then knows T1 is A, so you can express the last argument with the help of IntelliSense.

when you say "compiler cannot infer that T1 is A" you actually mean the IDE's auto completion feature, right? — Tim Pohlmann, Jul 13 '16 at 12:27
@TimPohlmann I've edited my question, concealing the irrelevant part. And yes, I mean IntelliSense auto completion feature does not work at that very specific moment. — QuantumHive, Jul 13 '16 at 12:35
One of the ideas behind the whole Roslyn project was to have one single compiler that both compiled the code and ran in IntelliSense. For some way however, IntelliSense is a little different than compiling stuff (I think more information is needed). So we still have some cases where IntelliSense just bails our, while code still happily compiles :-( — Steven, Jul 13 '16 at 14:21
@Steven so are you proposing that this is actually a bug in IntelliSense? — QuantumHive, Jul 13 '16 at 14:26
What kind of answer do you expect here? The kind of "It has not been implemented because there is too much nesting and it's rarely a use case"? Or "Roslyn wasn't optimized to understand incomplete code and this one had been left out"? What do you do if you get such an answer? — Stefan Steinegger, Jul 15 '16 at 13:04
@StefanSteinegger I expect a **confirmation** from experts on if this is a legit bug, or that this is an *intentional* limited feature by design. — QuantumHive, Jul 15 '16 at 13:06
I had a similar problem http://stackoverflow.com/questions/34883559/intellisense-cannot-infer-type-from-extention-method I've created a bug report https://connect.microsoft.com/VisualStudio/feedback/details/2263258/vs-2015-intellisense-cannot-infer-type-from-extention-method — George Vovos, Jul 18 '16 at 16:19

Ivan Yurchenko · Accepted Answer · 2016-07-15T13:47:05.027

4

If I understood you correctly, everything is working as expected for me in VS2013:

Your first case:

Your second case:

I'm starting to type the l. and IntelliSense shows me that l has a property B that can be used. So if I'm right and it infers correctly in VS2013 whereas it doesn't infer in VS2015, then it's definitely a bug in VS2015 IntelliSense that can be reported to Microsoft.

edited Jul 15 '16 at 13:47

answered Jul 15 '16 at 12:59

Ivan Yurchenko

3,762
1
21
35

1

You are using the first overload (the one with `` as open generic type arguments). This **does** work in **VS2015** (as I've mentioned in my question). The problem was that the second overload (the one with ``) didn't work in **VS2015**. Does that work in **VS2013**? Could you provide a screenshot if it *does* work in **VS2013**? – QuantumHive Jul 15 '16 at 13:03
1

I'm not sure if I completely understand what's your problem is, but for me it shows hints correctly for both `Helper` and `Helper>` regardless number of expressions. Please check the videos: 1) http://take.ms/Okfxx 2) http://take.ms/c5YZB However, if you would specify `Helper ` in the extension method and `Helper>` in your method it will think that `A` is `IEnumerable ` so won't show you the hint unless you take `First()` or something. – Ivan Yurchenko Jul 15 '16 at 13:28
1

In the screenshot you provided, you are using the *first* extension method (since it's `Helper>`). So I'm asking you if the *second* extension method also works in **VS2013** (using `FooBar` with `Helper`). If it works, then could you provide a screenshot proving that it works on the second extension method (the overload). – QuantumHive Jul 15 '16 at 13:33
Yes, I've got that. Could you check my videos please? – Ivan Yurchenko Jul 15 '16 at 13:33
1

I see, I can confirm that you are using the *second* extension method in **VS2013** (as I've described that that's the problem in my question). And it seems that *IntelliSense* for **VS2013** can infer the types while typing, whereas *IntelliSense* for **VS2015** cannot. So the question remains that if this is indeed a **bug**, or an **intentional** missing feature by **design**? – QuantumHive Jul 15 '16 at 13:38
1

Well, if IntelliSense **suggests** you the right property in the **VS2013** and **doesn't suggest** in **VS2015** when **it should**, especially if you tell that it **allows** you to compile **after** you finish typing, but doesn't help **while** you're typing, then it sounds like an obvious bug for me. I don't see any reasons to make such uncomfortable and confusing behavior intentionally. Of course I may be wrong but such "improvement" would seem very weird for me. – Ivan Yurchenko Jul 15 '16 at 13:42
1

I agree. As Steven said in the comments for my question: *For some way however, IntelliSense is a little different than compiling stuff (I think more information is needed)*. Since this is the **Roslyn** compiler in action. I'll wait until I can get an official confirmation. If not your answer will be marked as answered. After that I'll report it to Microsoft. – QuantumHive Jul 15 '16 at 13:48

score 2 · Answer 2 · edited Jun 20 '20 at 09:12

I found your question interesting and since I'm using VS 2015 I thought I could try it too. I got the same error as you did, so i guess it can be a VS bug, since in other versions it is working properly.

Here is my error:

And I also get No suggestions on CTRL + SPACE.

EDIT:

A similar bug can be seen here.

So, since in older versions of VS this works, then this is the reason why it can be considered a bug.

score 2 · Answer 3 · edited May 23 '17 at 10:28

As I said I had the same problem. (And here is the bug report)
It is not related to Expressions or IEnumerable.
Here is a simplified example

using System;

namespace ConsoleApplicationExpressionTree
{

    public static class Extentions
    {
        static void Main() { }
        static void AMethod(string[] args)
        {
            SetValue(new Customer(), e => e.Name   /*type here */, "TheName");

        }

        public static void SetValue<TEntity, TProperty>(TEntity instance, Func<TEntity, TProperty> expression, TProperty newValue)
        {

        }
    }
    public class Customer
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

I just noticed that if you remove the 3rd argument from the method it works !!!

using System;

namespace ConsoleApplicationExpressionTree
{

    public static class Extentions
    {
        static void Main() { }
        static void AMethod(string[] args)
        {
            SetValue(new Customer(), e => e.Name   /*type here */);

        }

        public static void SetValue<TEntity, TProperty>(TEntity instance, Func<TEntity, TProperty> expression)
        {

        }
    }
    public class Customer
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
}

So if you are very lucky you might be able to fix your current example by tweaking your parameters.
If not,you'll just have to wait for MS to fix it...

Open generic type arguments cannot be inferred from the usage

3 Answers3