/// <summary>Generates the information for a quick look into the type</summary> /// <param name="type">The type reference to look into</param> /// <returns>Returns a quick look at the type information</returns> public static QuickTypeInfo GenerateInfo(TypeReference type) { // Variables QuickTypeInfo info = new QuickTypeInfo(); string[] generics = TypeInfo.GetGenericParametersString( type.GenericParameters.ToArray() ); GetNames( type.FullName.Replace("&", ""), GetNamespace(type), generics, out info.unlocalizedName, out info.nonInstancedFullName, out info.fullName, out info.namespaceName, out info.name ); info.genericParameters = GenericParametersInfo.GenerateInfoArray(type.GenericParameters); if(info.genericParameters.Length == 0) { info.genericParameters = GetGenericParameters(type.FullName); } info.isGenericType = type.IsGenericParameter && (info.unlocalizedName == info.nonInstancedFullName); return info; }
/// <summary>Generates an array of generic parameter informations from the given collection generic parameter</summary> /// <param name="generics">The collection of generic parameters to look into</param> /// <returns>Returns an array of generic parameter informations</returns> public static GenericParametersInfo[] GenerateInfoArray(Collection <GenericParameter> generics) { // Variables GenericParametersInfo[] results = new GenericParametersInfo[generics.Count]; int i = 0; foreach (GenericParameter generic in generics) { results[i++] = GenerateInfo(generic); } return(results); }
/// <summary>Generates a generic parameter information of the given generic parameter</summary> /// <param name="generic">The generic parameter to look into</param> /// <returns>Returns the generic parameter information</returns> public static GenericParametersInfo GenerateInfo(GenericParameter generic) { // Variables GenericParametersInfo info = new GenericParametersInfo(); int i = 0; info.unlocalizedName = UnlocalizeName(generic.Name); info.name = QuickTypeInfo.MakeNameFriendly(generic.Name); info.constraints = new QuickTypeInfo[generic.Constraints.Count]; foreach (GenericParameterConstraint constraint in generic.Constraints) { info.constraints[i++] = QuickTypeInfo.GenerateInfo(constraint.ConstraintType); } return(info); }
/// <summary>Gets the list of information of generic parameters from the full name of the type</summary> /// <param name="fullName">The full name of the type</param> /// <returns>Returns the list of information of generic parameters</returns> public static GenericParametersInfo[] GetGenericParameters(string fullName) { // Variables int lt = fullName.IndexOf('<'); if(lt == -1) { return new GenericParametersInfo[0]; } List<GenericParametersInfo> results = new List<GenericParametersInfo>(); GenericParametersInfo info; int gt = fullName.LastIndexOf('>'); int scope = 0; int curr = lt + 1; for(int i = curr; i < fullName.Length; i++) { if(fullName[i] == '<') { scope++; } else if(fullName[i] == '>') { scope--; } if(scope < 0) { gt = i; break; } else if(fullName[i] == ',' && scope == 0) { // Variables info = new GenericParametersInfo(); info.name = Regex.Replace(fullName.Substring(curr, i - curr), pattern, ""); info.unlocalizedName = GenericParametersInfo.UnlocalizeName(info.name); info.name = MakeNameFriendly(info.name); info.constraints = new QuickTypeInfo[0]; results.Add(info); curr = i + 1; } } info = new GenericParametersInfo(); info.name = Regex.Replace(fullName.Substring(curr, gt - curr), pattern, ""); info.unlocalizedName = GenericParametersInfo.UnlocalizeName(info.name); info.name = MakeNameFriendly(info.name); info.constraints = new QuickTypeInfo[0]; results.Add(info); return results.ToArray(); }
/// <summary>Generates the method information from the given method definition</summary> /// <param name="method">The method definition to look into</param> /// <returns>Returns the method information</returns> public static MethodInfo GenerateInfo(MethodDefinition method) { // Variables MethodInfo info = new MethodInfo(); int index; info.isStatic = method.IsStatic; info.isVirtual = method.IsVirtual; info.isConstructor = method.IsConstructor; if (method.IsAssembly) { info.accessor = "internal"; } else if (method.IsFamily) { info.accessor = "protected"; } else if (method.IsPublic) { info.accessor = "public"; } else { info.accessor = "private"; } info.isProperty = method.IsGetter || method.IsSetter; info.isEvent = method.IsAddOn || method.IsRemoveOn; info.isOperator = method.Name.StartsWith("op_"); info.isConversionOperator = ( method.Name == "op_Explicit" || method.Name == "op_Implicit" ); info.implementedType = QuickTypeInfo.GenerateInfo(method.DeclaringType); info.returnType = QuickTypeInfo.GenerateInfo(method.ReturnType); if (info.isConstructor) { info.name = info.implementedType.name; index = info.name.IndexOf('<'); if (index != -1) { info.name = info.name.Substring(0, index); } } else if (info.isConversionOperator) { info.name = method.Name + "__" + info.returnType.name; } else if (info.isOperator) { info.name = method.Name.Substring(3); } else { info.name = method.Name; } info.partialFullName = method.FullName.Split("::")[1].Replace(",", ", "); if (info.isOperator) { info.partialFullName = info.name; } info.parameters = ParameterInfo.GenerateInfoArray(method.Parameters); info.genericParameters = GenericParametersInfo.GenerateInfoArray(method.GenericParameters); info.attributes = AttributeInfo.GenerateInfoArray(method.CustomAttributes); if (info.isConversionOperator) { info.modifier = $"static { method.Name.Substring(3).ToLower() } operator"; } else if (info.isOperator) { info.modifier = "static operator"; } else if (method.IsStatic) { info.modifier = "static"; } else if (method.IsAbstract) { info.modifier = "abstract"; } else if (method.IsVirtual && method.IsReuseSlot) { info.modifier = "override"; } else if (method.IsVirtual) { info.modifier = "virtual"; } else { info.modifier = ""; } info.isExtension = HasExtensionAttribute(info); info.isAbstract = method.IsAbstract; info.isOverriden = method.IsReuseSlot; 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); if (TypeInfo.ignorePrivate && PropertyInfo.GetAccessorId(info.accessor) == 0) { info.shouldDelete = true; } 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); }