public static string GetGenericName(IGenericDefinition genericDefinition, string leftBracket, string rightBracket, ILanguage language) { V_0 = false; if (genericDefinition as MethodDefinition != null) { V_0 = ((MethodDefinition)genericDefinition).get_HasOverrides(); } V_1 = GenericHelper.GetNonGenericName(genericDefinition.get_Name()); if (!V_0) { if (genericDefinition as MethodDefinition == null) { stackVariable70 = false; } else { stackVariable70 = ((MethodDefinition)genericDefinition).get_IsConstructor(); } if (!stackVariable70) { V_1 = GenericHelper.ReplaceInvalidCharactersName(language, V_1); } } if (genericDefinition.get_HasGenericParameters()) { V_2 = 0; if (genericDefinition as TypeDefinition != null) { V_3 = (genericDefinition as TypeDefinition).get_DeclaringType(); if (V_3 != null && V_3.get_HasGenericParameters()) { V_2 = V_3.get_GenericParameters().get_Count(); } } if (V_2 < genericDefinition.get_GenericParameters().get_Count()) { V_1 = String.Concat(V_1, leftBracket); while (V_2 < genericDefinition.get_GenericParameters().get_Count()) { V_4 = genericDefinition.get_GenericParameters().get_Item(V_2); if (V_4.get_IsCovariant()) { V_1 = String.Concat(V_1, "out "); } if (V_4.get_IsContravariant()) { V_1 = String.Concat(V_1, "in "); } V_1 = String.Concat(V_1, GenericHelper.ReplaceInvalidCharactersName(language, V_4.get_Name())); if (V_2 != genericDefinition.get_GenericParameters().get_Count() - 1) { V_1 = String.Concat(V_1, ", "); } V_2 = V_2 + 1; } V_1 = String.Concat(V_1, rightBracket); } } return(V_1); }
public static string GetGenericName(this IGenericDefinition self, ILanguage language, string leftBracket = "<", string rightBracket = ">") { if (self as TypeDefinition == null && self as MethodDefinition == null) { throw new Exception("Invalid generic member definition type."); } return(GenericHelper.GetGenericName(self, leftBracket, rightBracket, language)); }
public static string GetGenericName(IGenericDefinition genericDefinition, string leftBracket, string rightBracket, ILanguage language) { bool isExplicitMethodOverrides = false; if (genericDefinition is MethodDefinition) { isExplicitMethodOverrides = ((MethodDefinition)genericDefinition).HasOverrides; } string name = GetNonGenericName(genericDefinition.Name); if (!isExplicitMethodOverrides) { bool isConstructor = genericDefinition is MethodDefinition && ((MethodDefinition)genericDefinition).IsConstructor; if (!isConstructor) { name = ReplaceInvalidCharactersName(language, name); } } if (genericDefinition.HasGenericParameters) { int i = 0; if (genericDefinition is TypeDefinition) { TypeDefinition nestedType = genericDefinition as TypeDefinition; TypeDefinition parentType = nestedType.DeclaringType; if (parentType != null && parentType.HasGenericParameters) { i = parentType.GenericParameters.Count; } } if (i < genericDefinition.GenericParameters.Count) { name += leftBracket; for (; i < genericDefinition.GenericParameters.Count; i++) { GenericParameter currentGenericParameter = genericDefinition.GenericParameters[i]; if (currentGenericParameter.IsCovariant) { name += "out "; } if (currentGenericParameter.IsContravariant) { name += "in "; } name += ReplaceInvalidCharactersName(language, currentGenericParameter.Name); if (i != genericDefinition.GenericParameters.Count - 1) { name += ", "; } } name += rightBracket; } } return(name); }
public static string GetGenericName(IGenericDefinition genericDefinition, string leftBracket, string rightBracket, ILanguage language) { bool isExplicitMethodOverrides = false; if (genericDefinition is MethodDefinition) { isExplicitMethodOverrides = ((MethodDefinition)genericDefinition).HasOverrides; } string name = GetNonGenericName(genericDefinition.Name); if (!isExplicitMethodOverrides) { bool isConstructor = genericDefinition is MethodDefinition && ((MethodDefinition)genericDefinition).IsConstructor; if (!isConstructor) { name = ReplaceInvalidCharactersName(language, name); } } if (genericDefinition.HasGenericParameters) { int i = 0; if (genericDefinition is TypeDefinition) { TypeDefinition nestedType = genericDefinition as TypeDefinition; TypeDefinition parentType = nestedType.DeclaringType; if (parentType != null && parentType.HasGenericParameters) { i = parentType.GenericParameters.Count; } } if (i < genericDefinition.GenericParameters.Count) { name += leftBracket; for (; i < genericDefinition.GenericParameters.Count; i++) { GenericParameter currentGenericParameter = genericDefinition.GenericParameters[i]; if (currentGenericParameter.IsCovariant) { name += "out "; } if (currentGenericParameter.IsContravariant) { name += "in "; } name += ReplaceInvalidCharactersName(language, currentGenericParameter.Name); if (i != genericDefinition.GenericParameters.Count - 1) { name += ", "; } } name += rightBracket; } } return name; }
public static Type GetMemberType(Type perceivedType, Type parentType, AccessibleObject member) { IGenericDefinition m = member.GetAnnotation <IGenericDefinition>(typeof(IGenericDefinition)); if (m == null) { return(perceivedType); } return(ToGenericInstanceType(perceivedType, parentType, m)); }
public static string GetGenericFullName(this IGenericDefinition self, ILanguage language) { if (self as TypeDefinition != null) { return((self as TypeDefinition).GetGenericFullTypeDefinitionName(language)); } if (self as MethodDefinition == null) { throw new Exception("Invalid generic member definition type."); } V_0 = self as MethodDefinition; return(V_0.GetFriendlyFullMethodReferenceName(language, V_0.GenericMemberFullName(language), true)); }
public static string GetGenericFullName(this IGenericDefinition self, ILanguage language) { if (self is TypeDefinition) { return((self as TypeDefinition).GetGenericFullTypeDefinitionName(language)); } else if (self is MethodDefinition) { MethodDefinition methodDef = self as MethodDefinition; return(methodDef.GetFriendlyFullMethodReferenceName(language, methodDef.GenericMemberFullName(language), true)); } throw new Exception("Invalid generic member definition type."); }
/* AGPL */ public static string GetGenericFullName(this IGenericDefinition self, ILanguage language, bool includeNamespace = true) /* End AGPL */ { if (self is TypeDefinition) { /* AGPL */ return((self as TypeDefinition).GetGenericFullTypeDefinitionName(language, includeNamespace)); /* End AGPL */ } else if (self is MethodDefinition) { MethodDefinition methodDef = self as MethodDefinition; /* AGPL */ return(methodDef.GetFriendlyFullMethodReferenceName(language, methodDef.GenericMemberFullName(language, includeNamespace), true, includeNamespace)); /* End AGPL */ } throw new Exception("Invalid generic member definition type."); }
protected virtual void WriteGenericName(IGenericDefinition genericDefinition) { IGenericParameterProvider provider; string referenceName; if (genericDefinition is MethodDefinition) { referenceName = GetMethodName(genericDefinition as MethodDefinition); provider = genericDefinition as MethodDefinition; } else { referenceName = GetTypeName(genericDefinition as TypeDefinition); provider = genericDefinition as TypeDefinition; } WriteReference(referenceName, genericDefinition); WriteGenericParametersToDefinition(provider, WriteGenericParameterConstraints, true); }
protected virtual void PostWriteGenericParametersConstraints(IGenericDefinition generic) { }
public static GenericDefinition Parse(IGenericDefinition def) { return(Parse(def.Definition())); }
public static Type ToGenericInstanceType(Type perceivedType, Type parentType, IGenericDefinition m) { var def = DefinitionParser.Parse(m); return(ToGenericInstanceType(perceivedType, parentType, def)); }
protected override void PostWriteGenericParametersConstraints(IGenericDefinition generic) { /// As TypeParameter's constraints in generic types are wrote besides the declaration of the type parameter /// this method will only print the comentaries for the contradicting type parameter's overriding constraints if (!generic.HasGenericParameters) { return; } foreach (GenericParameter parameter in generic.GenericParameters) { if (IsTypeParameterRedeclaration(parameter) && ShouldWriteConstraintsAsComment(parameter)) { WriteLine(); StartWritingComment(); WriteToken("Of "); WriteReference(parameter.Name, null); WriteGenericParameterConstraints(parameter); EndWritingComment(); } } }
protected override void PostWriteGenericParametersConstraints(IGenericDefinition genericDefinition) { if (genericDefinition.HasGenericParameters) { foreach (GenericParameter genericParameter in genericDefinition.GenericParameters) { if (genericParameter.HasNotNullableValueTypeConstraint || genericParameter.HasDefaultConstructorConstraint || genericParameter.HasConstraints || genericParameter.HasReferenceTypeConstraint) { WriteConstraints(genericParameter); } } } }
public static Type ToGenericInstanceType(Type perceivedType, Type parentType, IGenericDefinition m) { // is a specialized type defined? var genericInstanceType = m.GenericInstanceType(); if (genericInstanceType != typeof(object)) return genericInstanceType; int genericParameter = -1; var genericArguments = m.GenericArguments(); // is a generic type definition class defined? var genericTypeDef = m.GenericTypeDefinition(); if (genericTypeDef == typeof (object)) { genericTypeDef = perceivedType; genericParameter = m.GenericParameter(); } // retrieve generic parameters if required. GenericTypeInfo parentGenericArguments = null; bool needParentGenericArguments = genericParameter >= 0 || genericArguments.Any(a => !(a is Type)); if (needParentGenericArguments) { parentGenericArguments = GenericInstanceFactory.GetGenericTypeInfo(parentType); if (parentGenericArguments == null) { // Can either happen when the generics reflection annotations where not preserved // (i.e. a bug) when the user did not call GetTypeReflectionSafe() on an object, // or when requesting generics info not for an instance type, e.g. typeof(List<>). // As the second case can be difficult to debug, we emit a warning. TODO: we should // probably not emit a warning when the user code runs in release mode. Log.W("dot42", string.Format("Unable to reconstruct generic type definition for type {0}, parent type {1}. Did you use obj.GetTypeReflectionSafe()? If you are reflecting on an open generic type, i.e. typeof(List<>) you can ignore this warning.", perceivedType.FullName, parentType.FullName)); return genericTypeDef; } } if (genericParameter != -1) { // ReSharper disable once PossibleNullReferenceException genericTypeDef = parentGenericArguments.GetGenericParameter(genericParameter); } if (genericArguments.Length > 0) { Type[] genericParameters = new Type[genericArguments.Length]; for (int i = 0; i < genericArguments.Length; ++i) { Type arg; var nestedGenDef = genericArguments[i] as IGenericDefinition; if (nestedGenDef != null) { arg = ToGenericInstanceType(typeof (object), parentType, nestedGenDef); } else { arg = genericArguments[i] as Type; if (arg == null) { // ReSharper disable once PossibleNullReferenceException arg = parentGenericArguments.GetGenericParameter((int) genericArguments[i]); } } genericParameters[i] = arg; } return GenericInstanceFactory.GetOrMakeGenericInstanceType(genericTypeDef, genericParameters); } // return the type. return genericTypeDef; }
private static Type ToMatchedGenericInstanceType(Type perceivedType, Type parentType, IGenericDefinition[] definitions) { for (int i = 0; i < definitions.Length; ++i) { if (definitions[i].GenericTypeDefinition() != perceivedType) continue; return ToGenericInstanceType(perceivedType, parentType, definitions[i]); } // we missed it, correct definition not found. just return perceivedType. return perceivedType; }