public TypeResolver(GenericInstanceType typeDefinitionContext, GenericInstanceMethod methodDefinitionContext)
{
_typeDefinitionContext = typeDefinitionContext;
_methodDefinitionContext = methodDefinitionContext;
}
public TypeResolver(GenericInstanceType typeDefinitionContext)
{
_typeDefinitionContext = typeDefinitionContext;
}
private static TypeDefinitionTreatment GenerateRedirectionInformation(TypeDefinition type, out Collection <MethodDefinition> redirectedMethods, out Collection <KeyValuePair <InterfaceImplementation, InterfaceImplementation> > redirectedInterfaces)
{
bool implementsProjectedInterface = false;
redirectedMethods = null;
redirectedInterfaces = null;
foreach (var implementedInterface in type.Interfaces)
{
if (IsRedirectedType(implementedInterface.InterfaceType))
{
implementsProjectedInterface = true;
break;
}
}
if (!implementsProjectedInterface)
{
return(TypeDefinitionTreatment.NormalType);
}
var allImplementedInterfaces = new HashSet <TypeReference> (new TypeReferenceEqualityComparer());
redirectedMethods = new Collection <MethodDefinition> ();
redirectedInterfaces = new Collection <KeyValuePair <InterfaceImplementation, InterfaceImplementation> > ();
foreach (var @interface in type.Interfaces)
{
var interfaceType = @interface.InterfaceType;
if (IsRedirectedType(interfaceType))
{
allImplementedInterfaces.Add(interfaceType);
CollectImplementedInterfaces(interfaceType, allImplementedInterfaces);
}
}
foreach (var implementedInterface in type.Interfaces)
{
var interfaceType = implementedInterface.InterfaceType;
if (IsRedirectedType(implementedInterface.InterfaceType))
{
var etype = interfaceType.GetElementType();
var unprojectedType = new TypeReference(etype.Namespace, etype.Name, etype.Module, etype.Scope)
{
DeclaringType = etype.DeclaringType,
projection = etype.projection
};
RemoveProjection(unprojectedType);
var genericInstanceType = interfaceType as GenericInstanceType;
if (genericInstanceType != null)
{
var genericUnprojectedType = new GenericInstanceType(unprojectedType);
foreach (var genericArgument in genericInstanceType.GenericArguments)
{
genericUnprojectedType.GenericArguments.Add(genericArgument);
}
unprojectedType = genericUnprojectedType;
}
var unprojectedInterface = new InterfaceImplementation(unprojectedType);
redirectedInterfaces.Add(new KeyValuePair <InterfaceImplementation, InterfaceImplementation> (implementedInterface, unprojectedInterface));
}
}
// Interfaces don't inherit methods of the interfaces they implement
if (!type.IsInterface)
{
foreach (var implementedInterface in allImplementedInterfaces)
{
RedirectInterfaceMethods(implementedInterface, redirectedMethods);
}
}
return(TypeDefinitionTreatment.RedirectImplementedMethods);
}
public TypeReference Resolve(TypeReference typeReference, bool includeTypeDefinitions)
{
if (IsDummy())
{
return(typeReference);
}
if (_typeDefinitionContext != null && _typeDefinitionContext.GenericArguments.Contains(typeReference))
{
return(typeReference);
}
if (_methodDefinitionContext != null && _methodDefinitionContext.GenericArguments.Contains(typeReference))
{
return(typeReference);
}
var genericParameter = typeReference as GenericParameter;
if (genericParameter != null)
{
if (_typeDefinitionContext != null && _typeDefinitionContext.GenericArguments.Contains(genericParameter))
{
return(genericParameter);
}
if (_methodDefinitionContext != null && _methodDefinitionContext.GenericArguments.Contains(genericParameter))
{
return(genericParameter);
}
return(ResolveGenericParameter(genericParameter));
}
var arrayType = typeReference as ArrayType;
if (arrayType != null)
{
return(new ArrayType(Resolve(arrayType.ElementType), arrayType.Rank));
}
var pointerType = typeReference as PointerType;
if (pointerType != null)
{
return(new PointerType(Resolve(pointerType.ElementType)));
}
var byReferenceType = typeReference as ByReferenceType;
if (byReferenceType != null)
{
return(new ByReferenceType(Resolve(byReferenceType.ElementType)));
}
var pinnedType = typeReference as PinnedType;
if (pinnedType != null)
{
return(new PinnedType(Resolve(pinnedType.ElementType)));
}
var genericInstanceType = typeReference as GenericInstanceType;
if (genericInstanceType != null)
{
var newGenericInstanceType = new GenericInstanceType(genericInstanceType.ElementType);
foreach (var genericArgument in genericInstanceType.GenericArguments)
{
newGenericInstanceType.GenericArguments.Add(Resolve(genericArgument));
}
return(newGenericInstanceType);
}
var requiredModType = typeReference as RequiredModifierType;
if (requiredModType != null)
{
return(Resolve(requiredModType.ElementType, includeTypeDefinitions));
}
if (includeTypeDefinitions)
{
var typeDefinition = typeReference as TypeDefinition;
if (typeDefinition != null && typeDefinition.HasGenericParameters)
{
var newGenericInstanceType = new GenericInstanceType(typeDefinition);
foreach (var gp in typeDefinition.GenericParameters)
{
newGenericInstanceType.GenericArguments.Add(Resolve(gp));
}
return(newGenericInstanceType);
}
}
if (typeReference is TypeSpecification)
{
throw new NotSupportedException(string.Format("The type {0} cannot be resolved correctly.", typeReference.FullName));
}
return(typeReference);
}
TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
switch (type.etype)
{
case ElementType.SzArray:
var vector = (ArrayType)type;
return(new ArrayType(ImportType(vector.ElementType, context)));
case ElementType.Ptr:
var pointer = (PointerType)type;
return(new PointerType(ImportType(pointer.ElementType, context)));
case ElementType.ByRef:
var byref = (ByReferenceType)type;
return(new ByReferenceType(ImportType(byref.ElementType, context)));
case ElementType.Pinned:
var pinned = (PinnedType)type;
return(new PinnedType(ImportType(pinned.ElementType, context)));
case ElementType.Sentinel:
var sentinel = (SentinelType)type;
return(new SentinelType(ImportType(sentinel.ElementType, context)));
case ElementType.FnPtr:
var fnptr = (FunctionPointerType)type;
var imported_fnptr = new FunctionPointerType()
{
HasThis = fnptr.HasThis,
ExplicitThis = fnptr.ExplicitThis,
CallingConvention = fnptr.CallingConvention,
ReturnType = ImportType(fnptr.ReturnType, context),
};
if (!fnptr.HasParameters)
{
return(imported_fnptr);
}
for (int i = 0; i < fnptr.Parameters.Count; i++)
{
imported_fnptr.Parameters.Add(new ParameterDefinition(
ImportType(fnptr.Parameters [i].ParameterType, context)));
}
return(imported_fnptr);
case ElementType.CModOpt:
var modopt = (OptionalModifierType)type;
return(new OptionalModifierType(
ImportType(modopt.ModifierType, context),
ImportType(modopt.ElementType, context)));
case ElementType.CModReqD:
var modreq = (RequiredModifierType)type;
return(new RequiredModifierType(
ImportType(modreq.ModifierType, context),
ImportType(modreq.ElementType, context)));
case ElementType.Array:
var array = (ArrayType)type;
var imported_array = new ArrayType(ImportType(array.ElementType, context));
if (array.IsVector)
{
return(imported_array);
}
var dimensions = array.Dimensions;
var imported_dimensions = imported_array.Dimensions;
imported_dimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
var dimension = dimensions [i];
imported_dimensions.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
return(imported_array);
case ElementType.GenericInst:
var instance = (GenericInstanceType)type;
var element_type = ImportType(instance.ElementType, context);
var arguments = instance.GenericArguments;
var imported_instance = new GenericInstanceType(element_type, arguments.Count);
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
{
imported_arguments.Add(ImportType(arguments [i], context));
}
return(imported_instance);
case ElementType.Var:
var var_parameter = (GenericParameter)type;
if (var_parameter.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(var_parameter.DeclaringType.FullName, var_parameter.Position));
case ElementType.MVar:
var mvar_parameter = (GenericParameter)type;
if (mvar_parameter.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(context.NormalizeMethodName(mvar_parameter.DeclaringMethod), mvar_parameter.Position));
}
throw new NotSupportedException(type.etype.ToString());
}