/// <summary>Gets the generic instanced type information</summary>
/// <param name="hash">The hashtable to change the generics into the instanced generics</param>
/// <param name="info">The information of the type to look into, should be the original</param>
/// <param name="ninfo">The information of the type to look into, should be generic instanced</param>
/// <param name="isGeneric">Set to true if anything was changed by this method</param>
/// <returns>Returns a quick look into the typing</returns>
public static QuickTypeInfo GetGenericInstanceTypeInfo(
Dictionary <string, QuickTypeInfo> hash, QuickTypeInfo info,
QuickTypeInfo ninfo, out bool isGeneric
)
{
isGeneric = false;
foreach (string key in hash.Keys)
{
// Variables
string arrayPattern = $@"{ key }((?:\[,*\])+)";
if (info.unlocalizedName == key)
{
info.unlocalizedName = hash[key].unlocalizedName;
}
if (info.unlocalizedName.Contains('.'))
{
info.namespaceName = Regex.Replace(info.unlocalizedName, @"(.*)\..*$", "$1");
}
else
{
info.namespaceName = "";
}
if (info.fullName == key)
{
info.fullName = hash[key].fullName;
isGeneric = true;
}
else if (info.fullName.Contains(key))
{
// Variables
string genericPattern = $@"([<,]){ key }([>,])";
info.fullName = Regex.Replace(
info.fullName,
genericPattern,
$"$1{ hash[key].fullName }$2"
);
info.fullName = Regex.Replace(
info.fullName,
arrayPattern,
$"{ hash[key].fullName }$1"
);
isGeneric = true;
}
}
if (isGeneric)
{
info.name = QuickTypeInfo.DeleteNamespaceFromType(
QuickTypeInfo.MakeNameFriendly(info.fullName)
);
}
if (info.fullName == info.name)
{
// Variables
string arrayPattern = $@"[a-zA-Z0-9]+((?:\[,*\])+)";
info.fullName = Regex.Replace(
info.fullName,
arrayPattern,
$"{ info.unlocalizedName }$1"
);
}
info.isGenericType = isGeneric && (info.unlocalizedName == info.nonInstancedFullName);
return(info);
}
/// <summary>Generates a generic instance of the method</summary>
/// <param name="method">The method to look into</param>
/// <param name="methodRef">The method reference to look into</param>
/// <returns>Returns the information into the method</returns>
public static MethodInfo GenerateInfo(MethodDefinition method, MethodReference methodRef)
{
// Variables
QuickTypeInfo ninfo = QuickTypeInfo.GenerateInfo(methodRef.DeclaringType);
MethodInfo info = GenerateInfo(method);
Dictionary <string, QuickTypeInfo> hash = new Dictionary <string, QuickTypeInfo>();
bool isGeneric = false;
int i = 0;
foreach (GenericParametersInfo generic in info.implementedType.genericParameters)
{
// Variables
QuickTypeInfo temp = new QuickTypeInfo();
temp.unlocalizedName = ninfo.genericParameters[i].unlocalizedName;
temp.fullName = ninfo.genericParameters[i].name;
temp.name = QuickTypeInfo.DeleteNamespaceFromType(QuickTypeInfo.MakeNameFriendly(temp.fullName));
if (temp.unlocalizedName.Contains('.'))
{
temp.namespaceName = Regex.Replace(temp.unlocalizedName, @"(.*)\..*$", "$1");
}
else
{
temp.namespaceName = "";
}
hash.Add(generic.name, temp);
i++;
}
foreach (ParameterInfo parameter in info.parameters)
{
parameter.typeInfo = GetGenericInstanceTypeInfo(hash, parameter.typeInfo, ninfo, out isGeneric);
if (isGeneric)
{
parameter.typeInfo.genericParameters = GenericParametersInfo.GenerateInfoArray(methodRef.Resolve().DeclaringType.GenericParameters);
parameter.genericParameterDeclarations = QuickTypeInfo.GetGenericParametersAsStrings(parameter.typeInfo.fullName);
parameter.fullDeclaration = ParameterInfo.GetFullDeclaration(parameter);
}
}
info.returnType = GetGenericInstanceTypeInfo(
hash,
info.returnType,
QuickTypeInfo.GenerateInfo(methodRef.ReturnType),
out isGeneric
);
info.declaration = (
info.accessor + " " +
(info.modifier != "" ? info.modifier + " " : "") +
(!info.isConstructor && !info.isConversionOperator ? info.returnType.name + " " : "") +
(!info.isConversionOperator ? info.name : info.returnType.name)
);
info.genericDeclaration = (info.genericParameters.Length > 0 && !method.IsGenericInstance ?
$"<{ string.Join(',', GetGenericParameterDeclaration(info.genericParameters)) }>" :
""
);
info.parameterDeclaration = string.Join(", ", GetParameterDeclaration(info));
if (info.isExtension)
{
info.parameterDeclaration = $"this { info.parameterDeclaration }";
}
info.fullDeclaration = $"{ info.declaration }{ info.genericDeclaration }({ info.parameterDeclaration })";
info.fullDeclaration += TypeInfo.GetGenericParameterConstraints(info.genericParameters);
return(info);
}