Dynamic generic argument to avoid reflection

[nd1012]

After benchmarking dynamic vs reflection, I want to use more dynamic, because it seems to be much faster in many situations. Right now I'm using something like this:

void Method() => Assert.AreEqual(typeof(bool), GenericMethod((dynamic)(object)true));

Type GenericMethod<T>(T value) where T : struct => typeof(T);

This works like a charm. But it'd be great, if something like this would be possible, too:

void Method() => Assert.AreEqual(typeof(bool), GenericMethod<dynamic(true.GetType())>());

Type GenericMethod<T>() where T : struct => typeof(T);

The difference here is, that I can use dynamic to call a generic method with an unknown value type - as long as the method consumes a parameter of the generic argument. If there's no parameter, I have no chance to call the GenericMethod, if I have the type of the generic argument T as a Type object only. Currently the only way to call GenericMethod of the 2nd example is using reflections with .MakeGenericMethod(...).Invoke(...) - which runs much slower than dynamic, as my benchmarks showed.

I wouldn't say that I really understand how the DLR works internal, but my idea was to allow dynamic(typeVariable) to be used as generic argument for a type or a method, which would be the most intuitive way for me, if only using a typeVariable would be not a good idea. However, I don't stick to it - I just think it'd be great, if a generic argument value could come from a variable, to be able to avoid using reflection for dynamic generic method calls.

My current workaround in such situations is to add a dummy parameter of the generic argument type for such kinds of method calls. If I want to call such a method dynamic, I use (dynamic)RuntimeHelpers.GetUninitializedObject(typeVariable) to get the default value for the dummy parameter.

void Method()
  => Assert.AreEqual(typeof(bool), GenericMethod((dynamic)RuntimeHelpers.GetUninitializedObject(true.GetType())));

Type GenericMethod<T>(T dummy) where T : struct => typeof(T);

That works, but to me it's ugly, because the default value has to be created, but is never being used anywhere in the method (there'll also be an information note IDE0060 raised from Visual Studio). For that reason I created a method which caches the default values.

What do you think - wouldn't dynamic generic arguments enrich C# and complete the DLR ?