|
private GetGenericMethodDefinition ( ) : |
||
| return | ||
protected virtual MethodInfo VisitMethod(MethodInfo methodToSearch)
{
var newReflectedType = VisitType(methodToSearch.ReflectedType);
if (newReflectedType != methodToSearch.ReflectedType)
{
methodToSearch = newReflectedType.GetMethod(methodToSearch.Name,
(methodToSearch.IsStatic ? BindingFlags.Static : BindingFlags.Instance)
| (methodToSearch.IsPublic
? BindingFlags.Public
: BindingFlags.NonPublic),
null,
methodToSearch.GetParameters().Select(x => x.ParameterType).ToArray(),
null);
}
if (!methodToSearch.IsGenericMethod)
return methodToSearch;
var genArgs = methodToSearch.GetGenericArguments();
var newGenArgs = genArgs.Select(VisitType).ToArray();
if (genArgs.SequenceEqual(newGenArgs))
return methodToSearch;
return methodToSearch.GetGenericMethodDefinition().MakeGenericMethod(newGenArgs);
}
public IHqlGeneratorForMethod GetMethodGenerator(MethodInfo method)
{
IHqlGeneratorForMethod methodGenerator;
if (method.IsGenericMethod)
{
method = method.GetGenericMethodDefinition();
}
if (_registeredMethods.TryGetValue(method, out methodGenerator))
{
return methodGenerator;
}
// No method generator registered. Look to see if it's a standard LinqExtensionMethod
var attr = method.GetCustomAttributes(typeof (LinqExtensionMethodAttribute), false);
if (attr.Length == 1)
{
// It is
// TODO - cache this? Is it worth it?
return new HqlGeneratorForExtensionMethod((LinqExtensionMethodAttribute) attr[0], method);
}
// Not that either. Let's query each type generator to see if it can handle it
foreach (var typeGenerator in _typeGenerators)
{
if (typeGenerator.SupportsMethod(method))
{
return typeGenerator.GetMethodGenerator(method);
}
}
throw new NotSupportedException(method.ToString());
}
public bool TryGetExpectProvider(MethodInfo method, out IMethodExpectProvider provider)
{
var foundExact = lookup.TryGetValue(method, out provider);
if(!foundExact && method.IsGenericMethod)
return lookup.TryGetValue(method.GetGenericMethodDefinition(), out provider);
return foundExact;
}
protected virtual IMethodCallTranslator GetItem(MethodInfo key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
IMethodCallTranslator translator;
if (Registry.TryGetValue(key, out translator))
{
return translator;
}
if (key.IsGenericMethod && !key.IsGenericMethodDefinition)
{
if (Registry.TryGetValue(key.GetGenericMethodDefinition(), out translator))
{
return translator;
}
}
// Check if the generic form of the declaring type matches
translator = GetItemFromGenericType(key);
if (translator != null)
{
return translator;
}
// Finally, check any interfaces that may have a matching
return GetItemFromInterfaces(key);
}
private MethodInfo EnsureClosedMethod(MethodInfo method)
{
if (method.ContainsGenericParameters)
{
return method.GetGenericMethodDefinition().MakeGenericMethod(this.genericMethodArguments);
}
return method;
}
protected virtual IMethodCallTranslator GetItem(MethodInfo key)
{
lock (Registry)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
IMethodCallTranslator translator;
if (Registry.TryGetValue(key, out translator))
{
return translator;
}
if (key.IsGenericMethod && !key.IsGenericMethodDefinition)
{
if (Registry.TryGetValue(key.GetGenericMethodDefinition(), out translator))
{
return translator;
}
}
// Check if the generic form of the declaring type matches
translator = GetItemFromGenericType(key);
if (translator != null)
{
return translator;
}
// Check any interfaces that may have a matching method
translator = GetItemFromInterfaces(key);
if (translator != null)
{
return translator;
}
// If no preregistered method is found, check to see if the method is decorated with N1QlFunctionAttribute
translator = CreateFromN1QlFunctionAttribute(key);
if (translator != null)
{
// Save this translator for reuse
Registry.Add(key, translator);
return translator;
}
// Finally, check base method if this is a virtual method
var baseMethod = key.GetBaseDefinition();
if ((baseMethod != null) && (baseMethod != key))
{
return GetItem(baseMethod);
}
// No match found
return null;
}
}
public static void EnsureSatisfiesClassConstraints(MethodInfo reflectionMethodInfo)
{
MethodInfo genericMethodDefinition = reflectionMethodInfo.GetGenericMethodDefinition();
TypeInfo[] methodArguments = TypesToTypeInfos(reflectionMethodInfo.GetGenericArguments());
TypeInfo[] methodParameters = TypesToTypeInfos(genericMethodDefinition.GetGenericArguments());
TypeInfo[] typeArguments = TypesToTypeInfos(reflectionMethodInfo.DeclaringType.GetGenericArguments());
SigTypeContext typeContext = new SigTypeContext(typeArguments, methodArguments);
EnsureSatisfiesClassConstraints(methodParameters, methodArguments, genericMethodDefinition, typeContext);
}
private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
{
ParameterInfo[] parameters = m.GetParameters();
if (parameters.Length != args.Count)
{
return false;
}
if ((!m.IsGenericMethod && (typeArgs != null)) && (typeArgs.Length > 0))
{
return false;
}
if ((!m.IsGenericMethodDefinition && m.IsGenericMethod) && m.ContainsGenericParameters)
{
m = m.GetGenericMethodDefinition();
}
if (m.IsGenericMethodDefinition)
{
if ((typeArgs == null) || (typeArgs.Length == 0))
{
return false;
}
if (m.GetGenericArguments().Length != typeArgs.Length)
{
return false;
}
m = m.MakeGenericMethod(typeArgs);
parameters = m.GetParameters();
}
int index = 0;
int count = args.Count;
while (index < count)
{
Type parameterType = parameters[index].ParameterType;
if (parameterType == null)
{
return false;
}
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
}
Expression operand = args[index];
if (!parameterType.IsAssignableFrom(operand.Type))
{
if (operand.NodeType == ExpressionType.Quote)
{
operand = ((UnaryExpression) operand).Operand;
}
if (!parameterType.IsAssignableFrom(operand.Type) && !parameterType.IsAssignableFrom(StripExpression(operand.Type)))
{
return false;
}
}
index++;
}
return true;
}
private static MethodInfo GetBaseDefinition(MethodInfo method)
{
if (method.IsGenericMethod && !method.IsGenericMethodDefinition)
{
method = method.GetGenericMethodDefinition();
}
return method.GetBaseDefinition();
}
public Maybe<ITransactionOptions> AsTransactional(MethodInfo target)
{
Contract.Requires(target != null);
Contract.Ensures(Contract.Result<Maybe<TransactionAttribute>>() != null);
var rawMethodInfo = target.IsGenericMethod ? target.GetGenericMethodDefinition() : target;
return _TxMethods.ContainsKey(rawMethodInfo)
? Maybe.Some<ITransactionOptions>(_TxMethods[rawMethodInfo])
: Maybe.None<ITransactionOptions>();
}
public static object InvokeGenericMethod(object instance, MethodInfo methodInfo, Type[] typeArguments, object[] parameters)
{
if (methodInfo == null)
throw new ArgumentNullException("methodInfo");
// Could check that methodInfo.GetParameters().Count() == parameters.Count(), and methodInfo.GetGenericArguments().Count() == typeArguments.Count() ?
var method = methodInfo.GetGenericMethodDefinition();
var genericMethod = method.MakeGenericMethod(typeArguments);
var result = genericMethod.Invoke(instance, parameters);
return result;
}
public virtual bool TryGetGenerator(MethodInfo method, out IHqlGeneratorForMethod generator)
{
if (method.IsGenericMethod)
{
method = method.GetGenericMethodDefinition();
}
if (registeredMethods.TryGetValue(method, out generator)) return true;
// Not that either. Let's query each type generator to see if it can handle it
if (GetRuntimeMethodGenerator(method, out generator)) return true;
return false;
}
public override IMethodInfo ImplementGenericPattern(MethodInfo method, Type[] typeArgs, Type[] methodArgs)
{
var jointArgs = new List<Type>();
var patternArgs = method.IsGenericMethod ? method.GetGenericMethodDefinition().GetGenericArguments() : new Type[0];
var patternMethodArgs = GetGenericPattern(method).GetMethodGenericArguments();
var patternTypeArgs = GetGenericPattern(method).GetTypeGenericArguments();
for (var i = 0; i < patternArgs.Length; ++i)
{
var patternArg = patternArgs[i];
for (var j = 0; j < patternMethodArgs.Length; ++j)
{
var patternMethodArg = patternMethodArgs[j];
if (patternMethodArg.SameMetadataToken(patternArg))
{
jointArgs.Add(methodArgs[j]);
break;
}
}
for (var j = 0; j < patternTypeArgs.Length; ++j)
{
var patternTypeArg = patternTypeArgs[j];
if (patternTypeArg.SameMetadataToken(patternArg))
{
jointArgs.Add(typeArgs[j]);
break;
}
}
}
var pattern = method.IsGenericMethod ? method.GetGenericMethodDefinition() : method;
return ForgedMethod.Forge(pattern.MakeGenericMethod(jointArgs.ToArray()), this);
}
private System.Reflection.MethodInfo ReplaceAnonymousType(System.Reflection.MethodInfo methodInfo)
{
if (methodInfo.IsGenericMethod)
{
var args =
from a in methodInfo.GetGenericArguments()
select ReplaceAnonymousType(a);
return(methodInfo.GetGenericMethodDefinition().MakeGenericMethod(args.ToArray()));
}
else
{
return(methodInfo);
}
}
static MethodInfo ExtractBaseMethod (MethodInfo info)
{
if (info is MethodBuilder)
return info;
if (info is MethodOnTypeBuilderInst)
return ((MethodOnTypeBuilderInst)info).base_method;
if (info.IsGenericMethod)
info = info.GetGenericMethodDefinition ();
Type t = info.DeclaringType;
if (!t.IsGenericType || t.IsGenericTypeDefinition)
return info;
return (MethodInfo)t.Module.ResolveMethod (info.MetadataToken);
}
public void Generate(MethodInfo newMethod)
{
if (newMethod.IsGenericMethod)
newMethod = newMethod.GetGenericMethodDefinition();
FieldInfo field = typeof (DynamicWrapperBase).GetField("UnderlyingObject", BindingFlags.Instance | BindingFlags.NonPublic);
ParameterInfo[] parameters = newMethod.GetParameters();
Type[] parameterTypes = Enumerable.ToArray<Type>(Enumerable.Select<ParameterInfo, Type>((IEnumerable<ParameterInfo>) parameters, (Func<ParameterInfo, Type>) (parameter => parameter.ParameterType)));
MethodBuilder methodBuilder = this._wrapperBuilder.DefineMethod(newMethod.Name, MethodAttributes.Public | MethodAttributes.Virtual, newMethod.ReturnType, parameterTypes);
if (newMethod.IsGenericMethod)
methodBuilder.DefineGenericParameters(Enumerable.ToArray<string>(Enumerable.Select<Type, string>((IEnumerable<Type>) newMethod.GetGenericArguments(), (Func<Type, string>) (arg => arg.Name))));
ILGenerator ilGenerator = methodBuilder.GetILGenerator();
WrapperMethodBuilder.LoadUnderlyingObject(ilGenerator, field);
WrapperMethodBuilder.PushParameters((ICollection<ParameterInfo>) parameters, ilGenerator);
this.ExecuteMethod((MethodBase) newMethod, parameterTypes, ilGenerator);
WrapperMethodBuilder.Return(ilGenerator);
}
public bool TryGetMethodGenerator(MethodInfo method, out IHqlGeneratorForMethod methodGenerator)
{
if (method.IsGenericMethod)
{
method = method.GetGenericMethodDefinition();
}
if (GetRegisteredMethodGenerator(method, out methodGenerator)) return true;
// No method generator registered. Look to see if it's a standard LinqExtensionMethod
if (GetStandardLinqExtensionMethodGenerator(method, out methodGenerator)) return true;
// Not that either. Let's query each type generator to see if it can handle it
if (GetMethodGeneratorForType(method, out methodGenerator)) return true;
return false;
}
private static MethodInfo ObtainMethod(MethodInfo proxiedMethod, Type type)
{
Type[] genericArguments = null;
if (proxiedMethod.IsGenericMethod)
{
genericArguments = proxiedMethod.GetGenericArguments();
proxiedMethod = proxiedMethod.GetGenericMethodDefinition();
}
Type declaringType = proxiedMethod.DeclaringType;
MethodInfo methodOnTarget = null;
if (declaringType.IsInterface)
{
var mapping = type.GetInterfaceMap(declaringType);
int index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
Debug.Assert(index != -1);
methodOnTarget = mapping.TargetMethods[index];
}
else
{
// NOTE: this implementation sucks, feel free to improve it.
var methods = MethodFinder.GetAllInstanceMethods(type, BindingFlags.Public | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (MethodSignatureComparer.Instance.Equals(method.GetBaseDefinition(), proxiedMethod))
{
methodOnTarget = method;
break;
}
}
}
if (methodOnTarget == null)
{
throw new ArgumentException(
string.Format("Could not find method overriding {0} on type {1}. This is most likely a bug. Please report it.",
proxiedMethod, type));
}
if (genericArguments == null)
{
return methodOnTarget;
}
return methodOnTarget.MakeGenericMethod(genericArguments);
}
private InterceptMethodElement FindInterceptMethodElement(InterceptContractElement interceptContractElement, MethodInfo method)
{
if (interceptContractElement == null)
return null;
if (interceptContractElement.Methods == null)
return null;
foreach (InterceptMethodElement interceptMethodElement in interceptContractElement.Methods)
{
string methodSignature = null;
if (method.IsGenericMethod)
methodSignature = method.GetGenericMethodDefinition().GetSignature();
else
methodSignature = method.GetSignature();
if (interceptMethodElement.Signature.Equals(methodSignature))
return interceptMethodElement;
}
return null;
}
static StackObject *GetGenericMethodDefinition_10(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
{
ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
StackObject *ptr_of_this_method;
StackObject *__ret = ILIntepreter.Minus(__esp, 1);
ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
System.Reflection.MethodInfo instance_of_this_method = (System.Reflection.MethodInfo) typeof(System.Reflection.MethodInfo).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
__intp.Free(ptr_of_this_method);
var result_of_this_method = instance_of_this_method.GetGenericMethodDefinition();
object obj_result_of_this_method = result_of_this_method;
if (obj_result_of_this_method is CrossBindingAdaptorType)
{
return(ILIntepreter.PushObject(__ret, __mStack, ((CrossBindingAdaptorType)obj_result_of_this_method).ILInstance));
}
return(ILIntepreter.PushObject(__ret, __mStack, result_of_this_method));
}
private static MethodInfo ObtainMethod(MethodInfo proxiedMethod, Type type)
{
Type[] genericArguments = null;
if (proxiedMethod.IsGenericMethod)
{
genericArguments = proxiedMethod.GetGenericArguments();
proxiedMethod = proxiedMethod.GetGenericMethodDefinition();
}
var declaringType = proxiedMethod.DeclaringType;
MethodInfo methodOnTarget = null;
if (declaringType.IsInterface && !type.IsInterface)
{
var mapping = type.GetInterfaceMap(declaringType);
var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
Debug.Assert(index != -1);
methodOnTarget = mapping.TargetMethods[index];
}
else
{
// NOTE: this implementation sucks, feel free to improve it.
var methods = MethodFinder.GetAllInstanceMethods(type, BindingFlags.Public | BindingFlags.NonPublic);
foreach (var method in methods)
{
if (MethodSignatureComparer.Instance.Equals(method.GetBaseDefinition(), proxiedMethod))
{
methodOnTarget = method;
break;
}
}
}
if (methodOnTarget == null)
{
return null;
}
if (genericArguments == null)
{
return methodOnTarget;
}
return methodOnTarget.MakeGenericMethod(genericArguments);
}
public static InferenceStrategy Derive(MethodInfo method)
{
Throw.If(!method.IsGenericMethod, "Method must be generic!");
var genericDefinition = method.GetGenericMethodDefinition();
var genericArguments = genericDefinition.GetGenericArguments();
var parameterTypes = genericDefinition.GetParameters().Select(p => p.ParameterType).ToList();
var inferencePaths = new List<IList<int>>(Enumerable.Repeat<IList<int>>(null, genericArguments.Length));
// for each parameter type, search for inference paths
var currentPath = new Stack<int>();
for (var i = 0; i < parameterTypes.Count; ++i)
{
currentPath.Push(i);
DeriveAllInferencePaths(parameterTypes[i], currentPath, inferencePaths, genericArguments);
currentPath.Pop();
}
return new InferenceStrategy
{
Method = genericDefinition,
InferencePaths = inferencePaths.AsReadOnly()
};
}
/// <summary>
/// Identifies methods as instances of known sequence operators.
/// </summary>
/// <param name="method"> Method info to identify </param>
/// <param name="sequenceMethod"> Identified sequence operator </param>
/// <returns>
/// <c>true</c> if method is known; <c>false</c> otherwise
/// </returns>
internal static bool TryIdentifySequenceMethod(MethodInfo method, out SequenceMethod sequenceMethod)
{
method = method.IsGenericMethod
? method.GetGenericMethodDefinition()
: method;
return _methodMap.TryGetValue(method, out sequenceMethod);
}
private static MethodInfo MakeGenericMethod(MethodInfo method, IEnumerable<Type> typeParameters)
{
if(!method.IsGenericMethodDefinition)
method = method.GetGenericMethodDefinition();
return method.MakeGenericMethod(typeParameters.ToArray());
}
private static bool ArgsMatch(MethodInfo m, ReadOnlyCollection<Expression> args, Type[] typeArgs)
{
ParameterInfo[] mParams = m.GetParameters();
if (mParams.Length != args.Count)
return false;
if (!m.IsGenericMethod && typeArgs != null && typeArgs.Length > 0)
{
return false;
}
if (!m.IsGenericMethodDefinition && m.IsGenericMethod && m.ContainsGenericParameters)
{
m = m.GetGenericMethodDefinition();
}
if (m.IsGenericMethodDefinition)
{
if (typeArgs == null || typeArgs.Length == 0)
return false;
if (m.GetGenericArguments().Length != typeArgs.Length)
return false;
m = m.MakeGenericMethod(typeArgs);
mParams = m.GetParameters();
}
for (int i = 0, n = args.Count; i < n; i++)
{
Type parameterType = mParams[i].ParameterType;
if (parameterType == null)
return false;
if (parameterType.IsByRef)
parameterType = parameterType.GetElementType();
Expression arg = args[i];
if (!parameterType.IsAssignableFrom(arg.Type))
{
if (arg.NodeType == ExpressionType.Quote)
{
arg = ((UnaryExpression)arg).Operand;
}
if (!parameterType.IsAssignableFrom(arg.Type) &&
!parameterType.IsAssignableFrom(StripExpression(arg.Type)))
{
return false;
}
}
}
return true;
}
private MethodInfo EnsureClosedMethod(MethodInfo method)
{
if (method.ContainsGenericParameters)
{
Debug.Assert(genericMethodArguments != null);
return method.GetGenericMethodDefinition().MakeGenericMethod(genericMethodArguments);
}
return method;
}
bool InvokeOptimizedMethod(IMethod method, MethodInfo mi, MethodInvocationExpression node)
{
if (Builtins_ArrayTypedConstructor == mi)
{
// optimize constructs such as:
// array(int, 2)
IType type = TypeSystemServices.GetReferencedType(node.Arguments[0]);
if (null != type)
{
EmitNewArray(type, node.Arguments[1]);
return true;
}
}
else if (mi.IsGenericMethod && Builtins_ArrayGenericConstructor == mi.GetGenericMethodDefinition())
{
// optimize constructs such as:
// array[of int](2)
IType type = method.ConstructedInfo.GenericArguments[0];
if (null != type)
{
EmitNewArray(type, node.Arguments[0]);
return true;
}
}
else if (Builtins_ArrayTypedCollectionConstructor == mi)
{
// optimize constructs such as:
// array(int, (1, 2, 3))
// array(byte, [1, 2, 3, 4])
IType type = TypeSystemServices.GetReferencedType(node.Arguments[0]);
if (null != type)
{
ListLiteralExpression items = node.Arguments[1] as ListLiteralExpression;
if (null != items)
{
EmitArray(type, items.Items);
PushType(type.MakeArrayType(1));
return true;
}
}
}
else if (Array_get_Length == mi)
{
// don't use ldlen for System.Array
if (!GetType(node.Target).IsArray)
return false;
// optimize constructs such as:
// len(anArray)
// anArray.Length
Visit(node.Target);
PopType();
_il.Emit(OpCodes.Ldlen);
PushType(TypeSystemServices.IntType);
return true;
}
return false;
}
private static MethodInfo EnsureNonGeneric(MethodInfo methodInfo)
{
return methodInfo.IsGenericMethod ? methodInfo.GetGenericMethodDefinition() : methodInfo;
}
public static bool IsLinqOperatorCall(MethodInfo mi)
{
if (mi.IsGenericMethod)
{
mi = mi.GetGenericMethodDefinition();
}
return method2operator.ContainsKey(mi);
}
private static bool ArgsMatch(MethodInfo methodInfo, IList<Expression> arguments, Type[] typeArgs)
{
ParameterInfo[] parameters = methodInfo.GetParameters();
if (parameters.Length != arguments.Count)
{
return false;
}
if (!methodInfo.IsGenericMethod && typeArgs != null && typeArgs.Length > 0)
{
return false;
}
if (!methodInfo.IsGenericMethodDefinition && methodInfo.IsGenericMethod && methodInfo.ContainsGenericParameters)
{
methodInfo = methodInfo.GetGenericMethodDefinition();
}
if (methodInfo.IsGenericMethodDefinition)
{
if (typeArgs == null || typeArgs.Length == 0)
{
return false;
}
if (methodInfo.GetGenericArguments().Length != typeArgs.Length)
{
return false;
}
methodInfo = methodInfo.MakeGenericMethod(typeArgs);
parameters = methodInfo.GetParameters();
}
for (int i = 0; i < arguments.Count; i++)
{
Type parameterType = parameters[i].ParameterType;
if (parameterType == null)
{
return false;
}
if (parameterType.IsByRef)
{
parameterType = parameterType.GetElementType();
}
Expression operand = arguments[i];
if (!parameterType.IsAssignableFrom(operand.Type))
{
if (operand.NodeType == ExpressionType.Quote)
{
operand = ((UnaryExpression)operand).Operand;
}
if (!parameterType.IsAssignableFrom(operand.Type) &&
!parameterType.IsAssignableFrom(StripExpression(operand.Type)))
{
return false;
}
}
}
return true;
}
protected static MethodInfo GetGenericMethodFromTypes(MethodInfo method, Type[] genericTypes)
{
if (!method.IsGenericMethod)
throw new ArgumentException("Generic types cannot be specified for a non-generic method: " + method.Name);
Type[] genericArguments = method.GetGenericArguments();
if (genericArguments.Length != genericTypes.Length)
throw new ArgumentException("An incorrect number of generic arguments was specified: " + genericTypes.Length + " (needed " + genericArguments.Length + ")");
method = method.GetGenericMethodDefinition().MakeGenericMethod(genericTypes);
return method;
}
internal static bool IsClosedFormOf(
this MethodInfo methodInfo, MethodInfo genericMethod)
=> methodInfo.IsGenericMethod &&
Equals(
methodInfo.GetGenericMethodDefinition(),
genericMethod);
protected static MethodInfo GetGenericMethodFromArguments(MethodInfo method, object[] args)
{
method = new[] {method.GetGenericMethodDefinition()}
.MatchingArguments(args)
.First()
.ToSpecializedMethod(args);
return method;
}
