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