public TypeReference ImportType(Type type, ImportGenericContext context, ImportGenericKind import_kind)
{
if (IsTypeSpecification(type) || ImportOpenGenericType(type, import_kind))
{
return(this.ImportTypeSpecification(type, context));
}
TypeReference provider = new TypeReference(string.Empty, type.Name, this.module, this.ImportScope(type.Assembly), type.IsValueType)
{
etype = ImportElementType(type)
};
if (IsNestedType(type))
{
provider.DeclaringType = this.ImportType(type.DeclaringType, context, import_kind);
}
else
{
provider.Namespace = type.Namespace ?? string.Empty;
}
if (type.IsGenericType)
{
ImportGenericParameters(provider, type.GetGenericArguments());
}
return(provider);
}
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);
}
private static bool ImportOpenGenericMethod(MethodBase method, ImportGenericKind import_kind)
{
if (method.IsGenericMethod && method.IsGenericMethodDefinition)
{
return(import_kind == ImportGenericKind.Open);
}
return(false);
}
private static bool ImportOpenGenericType(Type type, ImportGenericKind import_kind)
{
if (type.IsGenericType() && type.IsGenericTypeDefinition())
{
return(import_kind == ImportGenericKind.Open);
}
return(false);
}
private TypeReference ImportType(Type type, ImportGenericContext context, ImportGenericKind import_kind)
{
if (!IsTypeSpecification(type) && !ImportOpenGenericType(type, import_kind))
{
TypeReference typeReference = new TypeReference(string.Empty, type.Name, module, ImportScope(type), type.IsValueType());
typeReference.etype = ImportElementType(type);
if (IsNestedType(type))
{
typeReference.DeclaringType = ImportType(type.DeclaringType, context, import_kind);
}
else
{
typeReference.Namespace = (type.Namespace ?? string.Empty);
}
if (type.IsGenericType())
{
ImportGenericParameters(typeReference, type.GetGenericArguments());
}
return(typeReference);
}
return(ImportTypeSpecification(type, context));
}
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);
ElementType elementType = ImportElementType(type);
if (elementType != ElementType.None)
{
// TODO: Use some IL generated setter instead of SetValue (which is slow)
etypeField.SetValue(reference, (byte)elementType);
}
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);
}
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);
ElementType elementType = ImportElementType(type);
if (elementType != ElementType.None)
{
typeof(TypeReference).GetField("etype", SR.BindingFlags.NonPublic | SR.BindingFlags.Instance).SetValue(reference, elementType);
}
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);
}
public TypeReference ImportType (Type type, IGenericContext 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;
if (type.IsGenericType)
ImportGenericParameters (reference, type.GetGenericArguments ());
return reference;
}
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 bool ImportOpenGenericMethod(SR.MethodBase method, ImportGenericKind import_kind)
{
return(method.IsGenericMethod && method.IsGenericMethodDefinition && import_kind == ImportGenericKind.Open);
}
static bool ImportOpenGenericType(Type type, ImportGenericKind import_kind)
{
return(type.IsGenericType && type.IsGenericTypeDefinition && import_kind == ImportGenericKind.Open);
}
public MethodReference ImportMethod (SR.MethodBase method, IGenericContext 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 ());
var method_info = method as SR.MethodInfo;
reference.ReturnType = method_info != null
? ImportType (method_info.ReturnType, context ?? reference)
: ImportType (typeof (void), null);
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)));
reference.DeclaringType = declaring_type;
return reference;
}
public MethodReference ImportMethod(MethodBase method, ImportGenericContext context, ImportGenericKind import_kind)
{
MethodReference reference4;
if (IsMethodSpecification(method) || ImportOpenGenericMethod(method, import_kind))
{
return(this.ImportMethodSpecification(method, context));
}
TypeReference reference = this.ImportType(method.DeclaringType, context);
if (IsGenericInstance(method.DeclaringType))
{
method = method.Module.ResolveMethod(method.MetadataToken);
}
MethodReference provider = new MethodReference {
Name = method.Name,
HasThis = HasCallingConvention(method, CallingConventions.HasThis),
ExplicitThis = HasCallingConvention(method, CallingConventions.ExplicitThis),
DeclaringType = this.ImportType(method.DeclaringType, context, ImportGenericKind.Definition)
};
if (HasCallingConvention(method, CallingConventions.VarArgs))
{
provider.CallingConvention = (MethodCallingConvention)((byte)(provider.CallingConvention & MethodCallingConvention.VarArg));
}
if (method.IsGenericMethod)
{
ImportGenericParameters(provider, method.GetGenericArguments());
}
context.Push(provider);
try
{
TypeReference reference1;
MethodInfo info = method as MethodInfo;
if (info != null)
{
reference1 = this.ImportType(info.ReturnType, context);
}
else
{
ImportGenericContext context2 = new ImportGenericContext();
reference1 = this.ImportType(typeof(void), context2);
}
provider.ReturnType = reference1;
ParameterInfo[] parameters = method.GetParameters();
Collection <ParameterDefinition> collection = provider.Parameters;
int index = 0;
while (true)
{
if (index >= parameters.Length)
{
provider.DeclaringType = reference;
reference4 = provider;
break;
}
collection.Add(new ParameterDefinition(this.ImportType(parameters[index].ParameterType, context)));
index++;
}
}
finally
{
context.Pop();
}
return(reference4);
}
private MethodReference ImportMethod(MethodBase method, ImportGenericContext context, ImportGenericKind import_kind)
{
if (!IsMethodSpecification(method) && !ImportOpenGenericMethod(method, import_kind))
{
TypeReference declaringType = ImportType(method.DeclaringType, context);
if (IsGenericInstance(method.DeclaringType))
{
method = ResolveMethodDefinition(method);
}
MethodReference methodReference = new MethodReference
{
Name = method.Name,
HasThis = HasCallingConvention(method, CallingConventions.HasThis),
ExplicitThis = HasCallingConvention(method, CallingConventions.ExplicitThis),
DeclaringType = ImportType(method.DeclaringType, context, ImportGenericKind.Definition)
};
if (HasCallingConvention(method, CallingConventions.VarArgs))
{
methodReference.CallingConvention &= MethodCallingConvention.VarArg;
}
if (method.IsGenericMethod)
{
ImportGenericParameters(methodReference, method.GetGenericArguments());
}
context.Push(methodReference);
try
{
MethodInfo methodInfo = method as MethodInfo;
methodReference.ReturnType = ((methodInfo != (MethodInfo)null) ? ImportType(methodInfo.ReturnType, context) : ImportType(typeof(void), default(ImportGenericContext)));
ParameterInfo[] parameters = method.GetParameters();
Collection <ParameterDefinition> parameters2 = methodReference.Parameters;
for (int i = 0; i < parameters.Length; i++)
{
parameters2.Add(new ParameterDefinition(ImportType(parameters[i].ParameterType, context)));
}
methodReference.DeclaringType = declaringType;
return(methodReference);
}
finally
{
context.Pop();
}
}
return(ImportMethodSpecification(method, context));
}
public MethodReference ImportMethod(MethodBase method, ImportGenericContext context, ImportGenericKind import_kind)
{
MethodReference methodReference;
if (MetadataImporter.IsMethodSpecification(method) || MetadataImporter.ImportOpenGenericMethod(method, import_kind))
{
return(this.ImportMethodSpecification(method, context));
}
TypeReference typeReference = this.ImportType(method.DeclaringType, context);
if (MetadataImporter.IsGenericInstance(method.DeclaringType))
{
method = method.Module.ResolveMethod(method.MetadataToken);
}
MethodReference methodReference1 = new MethodReference()
{
Name = method.Name,
HasThis = MetadataImporter.HasCallingConvention(method, CallingConventions.HasThis),
ExplicitThis = MetadataImporter.HasCallingConvention(method, CallingConventions.ExplicitThis),
DeclaringType = this.ImportType(method.DeclaringType, context, ImportGenericKind.Definition)
};
if (MetadataImporter.HasCallingConvention(method, CallingConventions.VarArgs))
{
MethodReference callingConvention = methodReference1;
callingConvention.CallingConvention = callingConvention.CallingConvention & MethodCallingConvention.VarArg;
}
if (method.IsGenericMethod)
{
MetadataImporter.ImportGenericParameters(methodReference1, method.GetGenericArguments());
}
context.Push(methodReference1);
try
{
MethodInfo methodInfo = method as MethodInfo;
methodReference1.ReturnType = (methodInfo != null ? this.ImportType(methodInfo.ReturnType, context) : this.ImportType(typeof(void), new ImportGenericContext()));
ParameterInfo[] parameters = method.GetParameters();
Collection <ParameterDefinition> parameterDefinitions = methodReference1.Parameters;
for (int i = 0; i < (int)parameters.Length; i++)
{
parameterDefinitions.Add(new ParameterDefinition(this.ImportType(parameters[i].ParameterType, context)));
}
methodReference1.DeclaringType = typeReference;
methodReference = methodReference1;
}
finally
{
context.Pop();
}
return(methodReference);
}
static bool ImportOpenGenericType (Type type, ImportGenericKind import_kind)
{
return type.IsGenericType && type.IsGenericTypeDefinition && import_kind == ImportGenericKind.Open;
}
static bool ImportOpenGenericMethod (SR.MethodBase method, ImportGenericKind import_kind)
{
return method.IsGenericMethod && method.IsGenericMethodDefinition && import_kind == ImportGenericKind.Open;
}
private static bool ImportOpenGenericMethod(MethodBase method, ImportGenericKind import_kind) => (method.IsGenericMethod && (method.IsGenericMethodDefinition && (import_kind == ImportGenericKind.Open)));
private static bool ImportOpenGenericType(Type type, ImportGenericKind import_kind) => (type.IsGenericType && (type.IsGenericTypeDefinition && (import_kind == ImportGenericKind.Open)));
static bool ImportOpenGenericType(Type type, ImportGenericKind import_kind)
{
#if !NETFX_CORE
return type.IsGenericType && type.IsGenericTypeDefinition && import_kind == ImportGenericKind.Open;
#else
var typeInfo = type.GetTypeInfo();
return typeInfo.IsGenericType && typeInfo.IsGenericTypeDefinition && import_kind == ImportGenericKind.Open;
#endif
}
