/// <summary>Generates the information for the parameter given the parameter definition</summary>
/// <param name="parameter">The parameter definition to look into</param>
/// <returns>Returns the parameter information generated from the parameter definition</returns>
public static ParameterInfo GenerateInfo(ParameterDefinition parameter)
{
// Variables
ParameterInfo info = new ParameterInfo();
info.name = parameter.Name;
info.typeInfo = QuickTypeInfo.GenerateInfo(parameter.ParameterType);
info.attributes = AttributeInfo.GenerateInfoArray(parameter.CustomAttributes);
if (parameter.IsIn)
{
info.modifier = "in";
}
else if (parameter.IsOut)
{
info.modifier = "out";
}
else if (parameter.ParameterType.IsByReference)
{
info.modifier = "ref";
}
else if (HasParamsAttribute(info.attributes))
{
info.modifier = "params";
}
else
{
info.modifier = "";
}
info.isOptional = parameter.IsOptional;
info.defaultValue = $"{ parameter.Constant }";
info.genericParameterDeclarations = QuickTypeInfo.GetGenericParametersAsStrings(parameter.ParameterType.FullName);
info.fullDeclaration = GetFullDeclaration(info);
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);
}