MethodSpecification ImportMethodSpecification(MethodReference method, ImportGenericContext context)
{
if (!method.IsGenericInstance)
throw new NotSupportedException();
var instance = (GenericInstanceMethod)method;
var element_method = ImportMethod(instance.ElementMethod, context);
var imported_instance = new GenericInstanceMethod(element_method);
var arguments = instance.GenericArguments;
var imported_arguments = imported_instance.GenericArguments;
for (int i = 0; i < arguments.Count; i++)
imported_arguments.Add(ImportType(arguments[i], context));
return imported_instance;
}
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.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 imported_instance = new GenericInstanceType(element_type);
var arguments = instance.GenericArguments;
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;
return context.TypeParameter(type.DeclaringType.FullName, var_parameter.Position);
case ElementType.MVar:
var mvar_parameter = (GenericParameter)type;
return context.MethodParameter(mvar_parameter.DeclaringMethod.Name, mvar_parameter.Position);
}
throw new NotSupportedException(type.etype.ToString());
}
public MethodReference ImportMethod(MethodReference method, ImportGenericContext context)
{
if (method.IsGenericInstance)
return ImportMethodSpecification(method, context);
var declaring_type = ImportType(method.DeclaringType, context);
var reference = new MethodReference
{
Name = method.Name,
HasThis = method.HasThis,
ExplicitThis = method.ExplicitThis,
DeclaringType = declaring_type,
CallingConvention = method.CallingConvention,
};
if (method.HasGenericParameters)
ImportGenericParameters(reference, method);
context.Push(reference);
try
{
reference.ReturnType = ImportType(method.ReturnType, context);
if (!method.HasParameters)
return reference;
var reference_parameters = reference.Parameters;
var parameters = method.Parameters;
for (int i = 0; i < parameters.Count; i++)
reference_parameters.Add(
new ParameterDefinition(ImportType(parameters[i].ParameterType, context)));
return reference;
}
finally
{
context.Pop();
}
}
public TypeReference ImportType(TypeReference type, ImportGenericContext context)
{
if (type.IsTypeSpecification())
return ImportTypeSpecification(type, context);
var reference = new TypeReference(
type.Namespace,
type.Name,
module,
ImportScope(type.Scope),
type.IsValueType);
MetadataSystem.TryProcessPrimitiveTypeReference(reference);
if (type.IsNested)
reference.DeclaringType = ImportType(type.DeclaringType, context);
if (type.HasGenericParameters)
ImportGenericParameters(reference, type);
return reference;
}
TypeReference ImportTypeSpecification(Type type, ImportGenericContext context)
{
if (type.IsByRef)
return new ByReferenceType(ImportType(type.GetElementType(), context));
if (type.IsPointer)
return new PointerType(ImportType(type.GetElementType(), context));
if (type.IsArray)
return new ArrayType(ImportType(type.GetElementType(), context), type.GetArrayRank());
if (type.IsGenericType)
return ImportGenericInstance(type, context);
if (type.IsGenericParameter)
return ImportGenericParameter(type, context);
throw new NotSupportedException(type.FullName);
}
public FieldReference ImportField(FieldReference field, ImportGenericContext context)
{
var declaring_type = ImportType(field.DeclaringType, context);
context.Push(declaring_type);
try
{
return new FieldReference
{
Name = field.Name,
DeclaringType = declaring_type,
FieldType = ImportType(field.FieldType, context),
};
}
finally
{
context.Pop();
}
}
public TypeReference ImportType(Type type, ImportGenericContext context)
{
return ImportType(type, context, ImportGenericKind.Open);
}
public TypeReference ImportType(Type type, ImportGenericContext context, ImportGenericKind import_kind)
{
if (IsTypeSpecification(type) || ImportOpenGenericType(type, import_kind))
return ImportTypeSpecification(type, context);
var reference = new TypeReference(
string.Empty,
type.Name,
module,
ImportScope(type.Assembly),
type.IsValueType);
reference.etype = ImportElementType(type);
if (IsNestedType(type))
reference.DeclaringType = ImportType(type.DeclaringType, context, import_kind);
else
reference.Namespace = type.Namespace ?? string.Empty;
if (type.IsGenericType)
ImportGenericParameters(reference, type.GetGenericArguments());
return reference;
}
MethodReference ImportMethodSpecification(SR.MethodBase method, ImportGenericContext context)
{
var method_info = method as SR.MethodInfo;
if (method_info == null)
throw new InvalidOperationException();
var element_method = ImportMethod(method_info.GetGenericMethodDefinition(), context, ImportGenericKind.Definition);
var instance = new GenericInstanceMethod(element_method);
var arguments = method.GetGenericArguments();
var instance_arguments = instance.GenericArguments;
context.Push(element_method);
try
{
for (int i = 0; i < arguments.Length; i++)
instance_arguments.Add(ImportType(arguments[i], context));
return instance;
}
finally
{
context.Pop();
}
}
public MethodReference ImportMethod(SR.MethodBase method, ImportGenericContext context, ImportGenericKind import_kind)
{
if (IsMethodSpecification(method) || ImportOpenGenericMethod(method, import_kind))
return ImportMethodSpecification(method, context);
var declaring_type = ImportType(method.DeclaringType, context);
if (IsGenericInstance(method.DeclaringType))
method = method.Module.ResolveMethod(method.MetadataToken);
var reference = new MethodReference
{
Name = method.Name,
HasThis = HasCallingConvention(method, SR.CallingConventions.HasThis),
ExplicitThis = HasCallingConvention(method, SR.CallingConventions.ExplicitThis),
DeclaringType = ImportType(method.DeclaringType, context, ImportGenericKind.Definition),
};
if (HasCallingConvention(method, SR.CallingConventions.VarArgs))
reference.CallingConvention &= MethodCallingConvention.VarArg;
if (method.IsGenericMethod)
ImportGenericParameters(reference, method.GetGenericArguments());
context.Push(reference);
try
{
var method_info = method as SR.MethodInfo;
reference.ReturnType = method_info != null
? ImportType(method_info.ReturnType, context)
: ImportType(typeof(void), default(ImportGenericContext));
var parameters = method.GetParameters();
var reference_parameters = reference.Parameters;
for (int i = 0; i < parameters.Length; i++)
reference_parameters.Add(
new ParameterDefinition(ImportType(parameters[i].ParameterType, context)));
reference.DeclaringType = declaring_type;
return reference;
}
finally
{
context.Pop();
}
}
static TypeReference ImportGenericParameter(Type type, ImportGenericContext context)
{
if (context.IsEmpty)
throw new InvalidOperationException();
if (type.DeclaringMethod != null)
return context.MethodParameter(type.DeclaringMethod.Name, type.GenericParameterPosition);
if (type.DeclaringType != null)
return context.TypeParameter(NormalizedFullName(type.DeclaringType), type.GenericParameterPosition);
throw new InvalidOperationException();
}
TypeReference ImportGenericInstance(Type type, ImportGenericContext context)
{
var element_type = ImportType(type.GetGenericTypeDefinition(), context, ImportGenericKind.Definition);
var instance = new GenericInstanceType(element_type);
var arguments = type.GetGenericArguments();
var instance_arguments = instance.GenericArguments;
context.Push(element_type);
try
{
for (int i = 0; i < arguments.Length; i++)
instance_arguments.Add(ImportType(arguments[i], context));
return instance;
}
finally
{
context.Pop();
}
}
public FieldReference ImportField(SR.FieldInfo field, ImportGenericContext context)
{
var declaring_type = ImportType(field.DeclaringType, context);
if (IsGenericInstance(field.DeclaringType))
field = ResolveFieldDefinition(field);
context.Push(declaring_type);
try
{
return new FieldReference
{
Name = field.Name,
DeclaringType = declaring_type,
FieldType = ImportType(field.FieldType, context),
};
}
finally
{
context.Pop();
}
}
