/// <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); }