public static MethodSignatureMatch Match(this UnityEventFunction eventFunction, [NotNull] IMethod method)
{
if (method.ShortName != eventFunction.Name)
{
return(MethodSignatureMatch.NoMatch);
}
var match = MethodSignatureMatch.ExactMatch;
if (method.IsStatic != eventFunction.IsStatic)
{
match |= MethodSignatureMatch.IncorrectStaticModifier;
}
if (!HasMatchingParameters(eventFunction, method))
{
match |= MethodSignatureMatch.IncorrectParameters;
}
if (!HasMatchingReturnType(eventFunction, method))
{
match |= MethodSignatureMatch.IncorrectReturnType;
}
if (!HasMatchingTypeParameters(method))
{
match |= MethodSignatureMatch.IncorrectTypeParameters;
}
return(match);
}
public static MethodSignature AsMethodSignature(this UnityEventFunction eventFunction, IPsiModule module)
{
IType returnType = TypeFactory.CreateTypeByCLRName(eventFunction.ReturnType, module);
if (eventFunction.ReturnTypeIsArray)
{
returnType = TypeFactory.CreateArrayType(returnType, 1);
}
if (eventFunction.Parameters.Length == 0)
{
return(new MethodSignature(returnType, eventFunction.IsStatic));
}
var parameterTypes = new IType[eventFunction.Parameters.Length];
var parameterNames = new string[eventFunction.Parameters.Length];
for (var i = 0; i < eventFunction.Parameters.Length; i++)
{
var parameter = eventFunction.Parameters[i];
IType paramType = TypeFactory.CreateTypeByCLRName(parameter.ClrTypeName, module);
if (parameter.IsArray)
{
paramType = TypeFactory.CreateArrayType(paramType, 1);
}
parameterTypes[i] = paramType;
parameterNames[i] = parameter.Name;
}
return(new MethodSignature(returnType, eventFunction.IsStatic, parameterTypes, parameterNames));
}
private static bool HasMatchingParameters(UnityEventFunction eventFunction, IMethod method)
{
var matchingParameters = false;
if (method.Parameters.Count == eventFunction.Parameters.Length)
{
matchingParameters = true;
for (var i = 0; i < eventFunction.Parameters.Length && matchingParameters; i++)
{
if (!DoTypesMatch(method.Parameters[i].Type, eventFunction.Parameters[i].ClrTypeName,
eventFunction.Parameters[i].IsArray))
{
matchingParameters = false;
}
}
}
else
{
// TODO: This doesn't really handle optional parameters very well
// It's fine for the current usage (a single parameter, either there or not)
// but won't work for anything more interesting. Perhaps optional parameters
// should be modeled as overloads?
var optionalParameters = 0;
foreach (var parameter in eventFunction.Parameters)
{
if (parameter.IsOptional)
{
optionalParameters++;
}
}
if (method.Parameters.Count + optionalParameters == eventFunction.Parameters.Length)
{
matchingParameters = true;
}
}
return(matchingParameters);
}
public static MethodSignature AsMethodSignature(this UnityEventFunction eventFunction,
KnownTypesCache knownTypesCache, IPsiModule module)
{
var returnType = eventFunction.ReturnType.AsIType(knownTypesCache, module);
if (eventFunction.Parameters.Length == 0)
{
return(new MethodSignature(returnType, eventFunction.IsStatic));
}
var parameterTypes = new IType[eventFunction.Parameters.Length];
var parameterNames = new string[eventFunction.Parameters.Length];
for (var i = 0; i < eventFunction.Parameters.Length; i++)
{
var parameter = eventFunction.Parameters[i];
var paramType = parameter.TypeSpec.AsIType(knownTypesCache, module);
parameterTypes[i] = paramType;
parameterNames[i] = parameter.Name;
}
return(new MethodSignature(returnType, eventFunction.IsStatic, parameterTypes, parameterNames));
}
private static bool HasMatchingReturnType(UnityEventFunction eventFunction, IMethod method)
{
return(DoTypesMatch(method.ReturnType, eventFunction.ReturnType) ||
(eventFunction.CanBeCoroutine && IsEnumerator(method.ReturnType)));
}
private static bool HasMatchingReturnType(UnityEventFunction eventFunction, IMethod method)
{
return(DoTypesMatch(method.ReturnType, eventFunction.ReturnType, eventFunction.ReturnTypeIsArray) ||
(eventFunction.Coroutine && DoTypesMatch(method.ReturnType, ourEnumeratorType, false)));
}
