public DomCecilType(TypeReference typeReference)
{
this.classType = ClassType.Unknown;
this.Modifiers = Modifiers.None;
this.Name = DomCecilType.RemoveGenericParamSuffix(typeReference.Name);
this.Namespace = typeReference.Namespace;
}
public DomCecilType(TypeDefinition typeDefinition, bool loadInternal)
{
this.typeDefinition = typeDefinition;
this.loadInternal = loadInternal;
this.classType = GetClassType(typeDefinition);
this.Name = DomCecilType.RemoveGenericParamSuffix(typeDefinition.Name);
this.Namespace = typeDefinition.Namespace;
this.Modifiers = GetModifiers(typeDefinition.Attributes);
if (typeDefinition.BaseType != null)
{
this.baseType = DomCecilMethod.GetReturnType(typeDefinition.BaseType);
}
DomCecilMethod.AddAttributes(this, typeDefinition.CustomAttributes);
foreach (TypeReference interfaceReference in typeDefinition.Interfaces)
{
this.AddInterfaceImplementation(DomCecilMethod.GetReturnType(interfaceReference));
}
foreach (GenericParameter parameter in typeDefinition.GenericParameters)
{
TypeParameter tp = new TypeParameter(parameter.FullName);
tp.Variance = (TypeParameterVariance)(((uint)parameter.Attributes) & 3);
foreach (TypeReference tr in parameter.Constraints)
{
tp.AddConstraint(DomCecilMethod.GetReturnType(tr));
}
AddTypeParameter(tp);
}
}
public static IReturnType GetReturnType(MethodReference methodReference)
{
if (methodReference == null)
{
return(DomReturnType.Void);
}
return(DomReturnType.GetSharedReturnType(DomCecilType.RemoveGenericParamSuffix(methodReference.DeclaringType.FullName)));
}
/*
* // Check if 'type' has some decorations applied to it
* if (type is Mono.Cecil.TypeSpecification) {
* // Go through all levels of 'indirection', 'array dimensions'
* // and 'generic types' - in the end, we should get the actual
* // type of the ReturnType (but all data about its array
* // dimensions, levels of indirection and even its generic
* // parameters is correctly stored within ArrayCount and
* // ArrayDimensions, PointerNestingLevel and GenericArguments
* // respectively).
* if (type is ArrayType) {
* // This return type is obviously an array - add the rank
* ArrayType at = (ArrayType) type;
* if (arrays == null)
* arrays = new Stack<int>();
* arrays.Push(at.Rank);
* type = at.ElementType;
* } else else if (type is Mono.Cecil.ReferenceType) {
* Mono.Cecil.ReferenceType rt = (Mono.Cecil.ReferenceType) type;
* byRef = true;
* type = rt.ElementType;
* } else if (type is PointerType) {
* // The type is a pointer
* PointerType pt = (PointerType) type;
++pointerNestingLevel;
* type = pt.ElementType;
* // Go down one level
* } else {
* // TODO: Check if we loose some relevant info here
* type = ((TypeSpecification)type).ElementType;
* }*/
public static DomReturnType GetReturnType(TypeReference typeReference)
{
if (typeReference == null)
{
return(new DomReturnType(DomReturnType.Void.ToInvariantString()));
}
if (typeReference is Mono.Cecil.GenericInstanceType)
{
Mono.Cecil.GenericInstanceType genType = (Mono.Cecil.GenericInstanceType)typeReference;
DomReturnType result = GetReturnType(genType.ElementType);
foreach (TypeReference typeRef in genType.GenericArguments)
{
DomReturnType param = GetReturnType(typeRef);
foreach (IReturnTypePart part in result.Parts)
{
if (part.Tag is TypeDefinition)
{
TypeDefinition typeDef = (TypeDefinition)part.Tag;
foreach (TypeReference typeParam in typeDef.GenericParameters)
{
if (typeParam.Name == param.Name)
{
part.AddTypeParameter(param);
goto skip;
}
}
}
}
result.AddTypeParameter(param);
skip :;
}
return(result);
}
if (typeReference is Mono.Cecil.ArrayType)
{
Mono.Cecil.ArrayType arrType = (Mono.Cecil.ArrayType)typeReference;
DomReturnType result = GetReturnType(arrType.ElementType);
result.ArrayDimensions++;
result.SetDimension(result.ArrayDimensions - 1, arrType.Rank - 1);
return(result);
}
if (typeReference is Mono.Cecil.PointerType)
{
Mono.Cecil.PointerType ptrType = (Mono.Cecil.PointerType)typeReference;
DomReturnType result = GetReturnType(ptrType.ElementType);
if (result.ArrayDimensions > 0)
{
result.ArrayPointerNestingLevel++;
}
else
{
result.PointerNestingLevel++;
}
return(result);
}
if (typeReference is Mono.Cecil.ByReferenceType)
{
return(GetReturnType(((Mono.Cecil.ByReferenceType)typeReference).ElementType));
}
if (typeReference is Mono.Cecil.TypeDefinition)
{
Mono.Cecil.TypeDefinition typeDefinition = (Mono.Cecil.TypeDefinition)typeReference;
DomReturnType result;
if (typeDefinition.DeclaringType != null)
{
result = GetReturnType(typeDefinition.DeclaringType);
result.Parts.Add(new ReturnTypePart(typeDefinition.Name));
result.Tag = typeDefinition;
}
else
{
result = new DomReturnType(typeDefinition.Name);
result.Namespace = typeDefinition.Namespace;
result.Tag = typeDefinition;
}
return(result);
}
return(new DomReturnType(DomCecilType.RemoveGenericParamSuffix(typeReference.FullName)));
}