private AnalysisNet.Types.PointerType ExtractType(Cecil.ByReferenceType typeref)
{
AnalysisNet.Types.IType target = ExtractType(typeref.ElementType);
AnalysisNet.Types.PointerType type = new AnalysisNet.Types.PointerType(target);
return(type);
}
public BlittableByReferenceMarshalInfoWriter(ByReferenceType type, MarshalType marshalType, MarshalInfo marshalInfo) : base(type)
{
this._elementType = type.ElementType;
this._elementTypeMarshalInfoWriter = MarshalDataCollector.MarshalInfoWriterFor(this._elementType, marshalType, marshalInfo, false, true, false, null);
if (this._elementTypeMarshalInfoWriter.MarshaledTypes.Length > 1)
{
throw new InvalidOperationException(string.Format("BlittableByReferenceMarshalInfoWriter cannot marshal {0}&.", type.ElementType.FullName));
}
this._marshaledTypes = new MarshaledType[] { new MarshaledType(this._elementTypeMarshalInfoWriter.MarshaledTypes[0].Name + "*", this._elementTypeMarshalInfoWriter.MarshaledTypes[0].DecoratedName + "*") };
}
public void RefTypeEquality () {
var rt1 = new ByReferenceType(T1);
var rt1_2 = new ByReferenceType(T1_2);
var rt2 = new ByReferenceType(T2);
var rt3 = new ByReferenceType(T3);
Assert.IsFalse(TypeUtil.TypesAreEqual(rt1, T1));
Assert.IsTrue(TypeUtil.TypesAreEqual(rt1, rt1));
Assert.IsTrue(TypeUtil.TypesAreEqual(rt1, rt1_2));
Assert.IsFalse(TypeUtil.TypesAreEqual(rt1, rt2));
Assert.IsFalse(TypeUtil.TypesAreEqual(rt1, rt3));
}
private static TypeReference CreateSpecs(TypeReference type, Type type_info)
{
type = TryCreateGenericInstanceType(type, type_info);
int[] specs = type_info.specs;
if (!specs.IsNullOrEmpty <int>())
{
for (int i = 0; i < specs.Length; i++)
{
int num3 = specs[i];
switch (num3)
{
case -3:
type = new ArrayType(type);
break;
case -2:
type = new ByReferenceType(type);
break;
case -1:
type = new PointerType(type);
break;
default:
{
ArrayType type2 = new ArrayType(type);
type2.Dimensions.Clear();
int num2 = 0;
while (true)
{
if (num2 >= specs[i])
{
type = type2;
break;
}
ArrayDimension item = new ArrayDimension();
type2.Dimensions.Add(item);
num2++;
}
break;
}
}
}
}
return(type);
}
private static TypeReference CreateSpecs(TypeReference type, TypeParser.Type type_info)
{
type = TypeParser.TryCreateGenericInstanceType(type, type_info);
int[] typeInfo = type_info.specs;
if (typeInfo.IsNullOrEmpty <int>())
{
return(type);
}
for (int i = 0; i < (int)typeInfo.Length; i++)
{
switch (typeInfo[i])
{
case -3:
{
type = new ArrayType(type);
break;
}
case -2:
{
type = new ByReferenceType(type);
break;
}
case -1:
{
type = new PointerType(type);
break;
}
default:
{
ArrayType arrayType = new ArrayType(type);
arrayType.Dimensions.Clear();
for (int j = 0; j < typeInfo[i]; j++)
{
arrayType.Dimensions.Add(new ArrayDimension());
}
type = arrayType;
break;
}
}
}
return(type);
}
static TypeReference CreateSpecs(TypeReference type, Type type_info)
{
type = TryCreateGenericInstanceType(type, type_info);
var specs = type_info.specs;
if (specs.IsNullOrEmpty())
{
return(type);
}
for (int i = 0; i < specs.Length; i++)
{
switch (specs [i])
{
case Type.Ptr:
type = new PointerType(type);
break;
case Type.ByRef:
type = new ByReferenceType(type);
break;
case Type.SzArray:
type = new ArrayType(type);
break;
default:
var array = new ArrayType(type);
array.Dimensions.Clear();
for (int j = 0; j < specs [i]; j++)
{
array.Dimensions.Add(new ArrayDimension());
}
type = array;
break;
}
}
return(type);
}
private static TypeReference CreateSpecs(TypeReference type, Type type_info)
{
type = TryCreateGenericInstanceType(type, type_info);
int[] specs = type_info.specs;
if (specs.IsNullOrEmpty())
{
return(type);
}
for (int i = 0; i < specs.Length; i++)
{
switch (specs[i])
{
case -1:
type = new PointerType(type);
break;
case -2:
type = new ByReferenceType(type);
break;
case -3:
type = new ArrayType(type);
break;
default:
{
ArrayType arrayType = new ArrayType(type);
arrayType.Dimensions.Clear();
for (int j = 0; j < specs[i]; j++)
{
arrayType.Dimensions.Add(default(ArrayDimension));
}
type = arrayType;
break;
}
}
}
return(type);
}
static bool compareByReferenceTypes(ByReferenceType a, ByReferenceType b)
{
return compareTypeSpecifications(a, b);
}
public void Process(MethodDefinition methodDefinition)
{
var parameters = methodDefinition.Parameters.Select(CreateMarshalledParameter).ToArray();
// If everything ended up being a BlittableMarshaller, that means we don't need to do any Marshalling
if (parameters.All(x => x.Marshaller is BlittableMarshaller))
return;
var pinvokeMethod = new MethodDefinition(methodDefinition.Name, methodDefinition.Attributes, methodDefinition.ReturnType);
// Move PInvokeInfo to underlying native method
pinvokeMethod.PInvokeInfo = methodDefinition.PInvokeInfo;
pinvokeMethod.ImplAttributes = methodDefinition.ImplAttributes;
methodDefinition.PInvokeInfo = null;
methodDefinition.IsPInvokeImpl = false;
methodDefinition.ImplAttributes = MethodImplAttributes.IL;
var context = new MarshalCodeContext(assemblyDefinition, methodDefinition, true);
// Build method signature
foreach (var parameter in parameters)
{
// Push context
context.ManagedEmitters.Push(new ParameterMarshalledObjectEmitter(parameter.Parameter));
if (parameter.IsByReference)
context.ManagedEmitters.Push(new ByReferenceMarshalledObjectEmitter());
// Compute native type
var nativeType = parameter.Marshaller.GetNativeType(context);
if (parameter.IsByReference)
nativeType = new ByReferenceType(nativeType);
// Add native parameter to pinvoke method
parameter.NativeParameter = new ParameterDefinition(parameter.Parameter.Name, parameter.Parameter.Attributes, context.Assembly.MainModule.Import(nativeType));
pinvokeMethod.Parameters.Add(parameter.NativeParameter);
// Pop context
if (parameter.IsByReference)
context.ManagedEmitters.Pop();
context.ManagedEmitters.Pop();
}
// First, process marshallers which expect an empty stack (due to loop) and make sure they are stored in a local variable
foreach (var parameter in parameters.Where(x => x.Marshaller.ContainsLoops || (!(x.Marshaller is BlittableMarshaller) && x.IsByReference)))
{
// Store in a local (if we didn't do that, we could end up having loops with things on the stack)
var variableType = parameter.NativeParameterType;
parameter.Variable = new VariableDefinition(variableType);
methodDefinition.Body.Variables.Add(parameter.Variable);
// Out-only parameter? Nothing to do...
if (parameter.Parameter.IsOut && !parameter.Parameter.IsIn)
continue;
// Push context
context.ManagedEmitters.Push(new ParameterMarshalledObjectEmitter(parameter.Parameter));
if (parameter.IsByReference)
context.ManagedEmitters.Push(new ByReferenceMarshalledObjectEmitter());
context.NativeEmitters.Push(new VariableMarshalledObjectEmitter(parameter.Variable));
// Convert parameter
parameter.Marshaller.EmitStoreManagedToNative(context);
// Pop context
context.NativeEmitters.Pop();
if (parameter.IsByReference)
context.ManagedEmitters.Pop();
context.ManagedEmitters.Pop();
}
// Each marshaller is responsible for pushing one parameter to the stack
foreach (var parameter in parameters)
{
if (parameter.Variable != null)
{
// Already processed before and stored in a variable
context.ILProcessor.Emit(parameter.IsByReference ? OpCodes.Ldloca : OpCodes.Ldloc, parameter.Variable);
}
else
{
// Just process and keep it on the stack
context.ManagedEmitters.Push(new ParameterMarshalledObjectEmitter(parameter.Parameter));
parameter.Marshaller.EmitStoreManagedToNative(context);
context.ManagedEmitters.Pop();
}
}
// Emit call
context.ILProcessor.Emit(OpCodes.Call, pinvokeMethod);
VariableDefinition returnValue = null;
Marshaller returnMarshaller = null;
if (methodDefinition.ReturnType.MetadataType != MetadataType.Void)
{
returnMarshaller = Marshaller.FindMarshallerForType(methodDefinition.ReturnType, null);
// Find native return type
context.ManagedEmitters.Push(new FakeMarshalledObjectEmitter(methodDefinition.ReturnType));
var nativeReturnType = returnMarshaller.GetNativeType(context);
context.ManagedEmitters.Pop();
// Change return type to native one
pinvokeMethod.ReturnType = nativeReturnType;
// Store return value in local variable
returnValue = new VariableDefinition("returnValue", nativeReturnType);
methodDefinition.Body.Variables.Add(returnValue);
context.ILProcessor.Emit(OpCodes.Stloc, returnValue);
}
// Emit setup
// TODO: Force Out parameter to have local variables? (source)
foreach (var parameter in parameters)
{
if (parameter.Parameter.IsOut && parameter.Variable != null)
{
context.NativeEmitters.Push(new VariableMarshalledObjectEmitter(parameter.Variable));
context.ManagedEmitters.Push(new ParameterMarshalledObjectEmitter(parameter.Parameter));
parameter.Marshaller.EmitStoreNativeToManaged(context);
context.ManagedEmitters.Pop();
context.NativeEmitters.Pop();
}
}
// TODO: Cleanup
// Emit return value
if (returnValue != null)
{
// Convert return value to managed type
context.NativeEmitters.Push(new VariableMarshalledObjectEmitter(returnValue));
returnMarshaller.EmitStoreNativeToManaged(context);
context.NativeEmitters.Pop();
}
context.ILProcessor.Emit(OpCodes.Ret);
// Add method to type
methodDefinition.DeclaringType.Methods.Add(pinvokeMethod);
methodDefinition.Body.UpdateInstructionOffsets();
}
private TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
switch (type.etype)
{
case ElementType.SzArray:
{
ArrayType arrayType = (ArrayType)type;
return(new ArrayType(ImportType(arrayType.ElementType, context)));
}
case ElementType.Ptr:
{
PointerType pointerType = (PointerType)type;
return(new PointerType(ImportType(pointerType.ElementType, context)));
}
case ElementType.ByRef:
{
ByReferenceType byReferenceType = (ByReferenceType)type;
return(new ByReferenceType(ImportType(byReferenceType.ElementType, context)));
}
case ElementType.Pinned:
{
PinnedType pinnedType = (PinnedType)type;
return(new PinnedType(ImportType(pinnedType.ElementType, context)));
}
case ElementType.Sentinel:
{
SentinelType sentinelType = (SentinelType)type;
return(new SentinelType(ImportType(sentinelType.ElementType, context)));
}
case ElementType.FnPtr:
{
FunctionPointerType functionPointerType = (FunctionPointerType)type;
FunctionPointerType functionPointerType2 = new FunctionPointerType
{
HasThis = functionPointerType.HasThis,
ExplicitThis = functionPointerType.ExplicitThis,
CallingConvention = functionPointerType.CallingConvention,
ReturnType = ImportType(functionPointerType.ReturnType, context)
};
if (!functionPointerType.HasParameters)
{
return(functionPointerType2);
}
for (int j = 0; j < functionPointerType.Parameters.Count; j++)
{
functionPointerType2.Parameters.Add(new ParameterDefinition(ImportType(functionPointerType.Parameters[j].ParameterType, context)));
}
return(functionPointerType2);
}
case ElementType.CModOpt:
{
OptionalModifierType optionalModifierType = (OptionalModifierType)type;
return(new OptionalModifierType(ImportType(optionalModifierType.ModifierType, context), ImportType(optionalModifierType.ElementType, context)));
}
case ElementType.CModReqD:
{
RequiredModifierType requiredModifierType = (RequiredModifierType)type;
return(new RequiredModifierType(ImportType(requiredModifierType.ModifierType, context), ImportType(requiredModifierType.ElementType, context)));
}
case ElementType.Array:
{
ArrayType arrayType2 = (ArrayType)type;
ArrayType arrayType3 = new ArrayType(ImportType(arrayType2.ElementType, context));
if (arrayType2.IsVector)
{
return(arrayType3);
}
Collection <ArrayDimension> dimensions = arrayType2.Dimensions;
Collection <ArrayDimension> dimensions2 = arrayType3.Dimensions;
dimensions2.Clear();
for (int k = 0; k < dimensions.Count; k++)
{
ArrayDimension arrayDimension = dimensions[k];
dimensions2.Add(new ArrayDimension(arrayDimension.LowerBound, arrayDimension.UpperBound));
}
return(arrayType3);
}
case ElementType.GenericInst:
{
GenericInstanceType genericInstanceType = (GenericInstanceType)type;
GenericInstanceType genericInstanceType2 = new GenericInstanceType(ImportType(genericInstanceType.ElementType, context));
Collection <TypeReference> genericArguments = genericInstanceType.GenericArguments;
Collection <TypeReference> genericArguments2 = genericInstanceType2.GenericArguments;
for (int i = 0; i < genericArguments.Count; i++)
{
genericArguments2.Add(ImportType(genericArguments[i], context));
}
return(genericInstanceType2);
}
case ElementType.Var:
{
GenericParameter genericParameter2 = (GenericParameter)type;
if (genericParameter2.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(genericParameter2.DeclaringType.FullName, genericParameter2.Position));
}
case ElementType.MVar:
{
GenericParameter genericParameter = (GenericParameter)type;
if (genericParameter.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(context.NormalizeMethodName(genericParameter.DeclaringMethod), genericParameter.Position));
}
default:
throw new NotSupportedException(type.etype.ToString());
}
}
/// <summary>
/// Check the given type.
/// </summary>
private bool Check(ByReferenceType type, string context)
{
return Check(type.ElementType, context);
}
static TypeReference ImportType(TypeReference typeRef, ModuleDefinition mod,
MethodReference context, Dictionary<MetadataToken, IMemberDefinition> mems)
{
TypeReference ret = typeRef;
if (typeRef is TypeSpecification)
{
if (typeRef is ArrayType)
{
ArrayType _spec = typeRef as ArrayType;
ret = new ArrayType(ImportType(_spec.ElementType, mod, context, mems));
(ret as ArrayType).Dimensions.Clear();
foreach (var i in _spec.Dimensions) (ret as ArrayType).Dimensions.Add(i);
}
else if (typeRef is GenericInstanceType)
{
GenericInstanceType _spec = typeRef as GenericInstanceType;
ret = new GenericInstanceType(ImportType(_spec.ElementType, mod, context, mems));
foreach (var i in _spec.GenericArguments) (ret as GenericInstanceType).GenericArguments.Add(ImportType(i, mod, context, mems));
}
else if (typeRef is OptionalModifierType)
{
ret = new OptionalModifierType(ImportType((typeRef as OptionalModifierType).ModifierType, mod, context, mems),
ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is RequiredModifierType)
{
ret = new RequiredModifierType(ImportType((typeRef as RequiredModifierType).ModifierType, mod, context, mems),
ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
}
else if (typeRef is ByReferenceType)
ret = new ByReferenceType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
else if (typeRef is PointerType)
ret = new PointerType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
else if (typeRef is PinnedType)
ret = new PinnedType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
else if (typeRef is SentinelType)
ret = new SentinelType(ImportType((typeRef as TypeSpecification).ElementType, mod, context, mems));
else
throw new NotSupportedException();
}
else if (typeRef is GenericParameter)
{
if (context == null || (typeRef as GenericParameter).Owner is TypeReference ||
(typeRef as GenericParameter).Position >= context.GenericParameters.Count)
return typeRef;
return context.GenericParameters[(typeRef as GenericParameter).Position];
}
else
{
if (mems != null && mems.ContainsKey(typeRef.MetadataToken))
ret = mems[typeRef.MetadataToken] as TypeReference;
else if (!(ret is TypeDefinition) && typeRef.Scope.Name != "Confuser.Core.Injections.dll")
ret = mod.Import(ret);
}
return ret;
}
public JSNewExpression NewMemberReference(JSExpression target, JSLiteral member)
{
var resultType = new ByReferenceType(member.GetActualType(TypeSystem));
return new JSNewExpression(
Dot("MemberReference", resultType),
null, null, target, member
);
}
static bool compareByReferenceTypes(Type a, ByReferenceType b)
{
if (!a.IsByRef)
return false;
return compareTypes(a.GetElementType(), b.ElementType);
}
private static ByReferenceType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, ByReferenceType byReferenceType)
{
return(new ByReferenceType(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, byReferenceType.ElementType)));
}
/// <summary>
/// Finds a type in the input module based on a type in any other module.
/// </summary>
/// <returns>The found type or either null or the imported type.</returns>
/// <param name="type">Type to find.</param>
/// <param name="context">Context containing some info.</param>
/// <param name="fallbackToImport">If set to <c>true</c> this method returns the type to find as imported in the input module.</param>
public virtual TypeReference FindType(TypeReference type, MemberReference context = null, bool fallbackToImport = true, bool loadedDependency = false)
{
if (type == null) {
Log("ERROR: Can't find null type!");
Log(Environment.StackTrace);
return null;
}
string typeName = RemovePrefixes(type.FullName, type);
TypeReference foundType = Module.GetType(typeName);
if (foundType == null && type.IsByReference) {
foundType = new ByReferenceType(FindType(((ByReferenceType) type).ElementType, context, fallbackToImport));
}
if (foundType == null && type.IsArray) {
foundType = new ArrayType(FindType(((ArrayType) type).ElementType, context, fallbackToImport), ((ArrayType) type).Dimensions.Count);
}
if (foundType == null && context != null && type.IsGenericParameter) {
foundType = FindTypeGeneric(type, context, fallbackToImport);
}
if (foundType == null && context != null && type.IsGenericInstance) {
foundType = new GenericInstanceType(FindType(((GenericInstanceType) type).ElementType, context, fallbackToImport));
foreach (TypeReference genericArgument in ((GenericInstanceType) type).GenericArguments) {
((GenericInstanceType) foundType).GenericArguments.Add(FindType(genericArgument, context));
}
}
if (foundType == null) {
foreach (ModuleDefinition dependency in Dependencies) {
foundType = dependency.GetType(typeName);
if (foundType != null) {
return Module.Import(foundType);
}
}
}
if (foundType != null && foundType.IsDefinition) {
IsBlacklisted(foundType.Module.Name, foundType.FullName, HasAttribute(foundType.Resolve(), "MonoModBlacklisted"));
}
if (type.IsGenericParameter) {
return foundType ?? (fallbackToImport ? type : null);
}
if (foundType == null && type.IsDefinition && type.Scope.Name.EndsWith(".mm")) {
foundType = PatchType((TypeDefinition) type);
}
if (foundType == null) {
if (!loadedDependency) {
LoadDependency(type.Scope.Name);
return FindType(type, context, fallbackToImport, true);
} else {
Log("debug: Type not found: " + type.FullName);
Log("debug: Type scope : " + type.Scope.Name);
}
}
return foundType ?? (fallbackToImport ? Module.Import(type) : null);
}
public JSNewArrayElementReference NewElementReference (JSExpression target, JSExpression index) {
var arrayType = TypeUtil.DereferenceType(target.GetActualType(TypeSystem));
TypeReference resultType;
if (PackedArrayUtil.IsPackedArrayType(arrayType)) {
resultType = new ByReferenceType(
PackedArrayUtil.GetElementType(arrayType)
);
} else if (TypeUtil.IsArray(arrayType)) {
resultType = new ByReferenceType(
TypeUtil.GetElementType(arrayType, true)
);
} else {
throw new ArgumentException("Cannot create a reference to an element of a value of type '" + arrayType.FullName + "'", target.ToString());
}
if (PackedArrayUtil.IsPackedArrayType(target.GetActualType(TypeSystem)))
return new JSNewPackedArrayElementReference(resultType, target, index);
else
return new JSNewArrayElementReference(resultType, target, index);
}
private string HandleByReferenceType(ByReferenceType parameterType)
{
TypeReference elementType = parameterType.ElementType;
string typeResult = string.Format("{0}@", GetParameterTypeRepresentation(elementType));
return typeResult;
}
private TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
ElementType elementType = type.etype;
if (elementType > ElementType.CModOpt)
{
if (elementType == ElementType.Sentinel)
{
SentinelType sentinelType = (SentinelType)type;
return(new SentinelType(this.ImportType(sentinelType.ElementType, context)));
}
if (elementType == ElementType.Pinned)
{
PinnedType pinnedType = (PinnedType)type;
return(new PinnedType(this.ImportType(pinnedType.ElementType, context)));
}
}
else
{
switch (elementType)
{
case ElementType.Ptr:
{
PointerType pointerType = (PointerType)type;
return(new PointerType(this.ImportType(pointerType.ElementType, context)));
}
case ElementType.ByRef:
{
ByReferenceType byReferenceType = (ByReferenceType)type;
return(new ByReferenceType(this.ImportType(byReferenceType.ElementType, context)));
}
case ElementType.ValueType:
case ElementType.Class:
{
break;
}
case ElementType.Var:
{
GenericParameter genericParameter = (GenericParameter)type;
if (genericParameter.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(genericParameter.DeclaringType.FullName, genericParameter.Position));
}
case ElementType.Array:
{
ArrayType arrayType = (ArrayType)type;
ArrayType arrayType1 = new ArrayType(this.ImportType(arrayType.ElementType, context));
if (arrayType.IsVector)
{
return(arrayType1);
}
Collection <ArrayDimension> dimensions = arrayType.Dimensions;
Collection <ArrayDimension> arrayDimensions = arrayType1.Dimensions;
arrayDimensions.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
ArrayDimension item = dimensions[i];
arrayDimensions.Add(new ArrayDimension(item.LowerBound, item.UpperBound));
}
return(arrayType1);
}
case ElementType.GenericInst:
{
GenericInstanceType genericInstanceType = (GenericInstanceType)type;
GenericInstanceType genericInstanceType1 = new GenericInstanceType(this.ImportType(genericInstanceType.ElementType, context));
Collection <TypeReference> genericArguments = genericInstanceType.GenericArguments;
Collection <TypeReference> typeReferences = genericInstanceType1.GenericArguments;
for (int j = 0; j < genericArguments.Count; j++)
{
typeReferences.Add(this.ImportType(genericArguments[j], context));
}
return(genericInstanceType1);
}
default:
{
switch (elementType)
{
case ElementType.SzArray:
{
ArrayType arrayType2 = (ArrayType)type;
return(new ArrayType(this.ImportType(arrayType2.ElementType, context)));
}
case ElementType.MVar:
{
GenericParameter genericParameter1 = (GenericParameter)type;
if (genericParameter1.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(context.NormalizeMethodName(genericParameter1.DeclaringMethod), genericParameter1.Position));
}
case ElementType.CModReqD:
{
RequiredModifierType requiredModifierType = (RequiredModifierType)type;
return(new RequiredModifierType(this.ImportType(requiredModifierType.ModifierType, context), this.ImportType(requiredModifierType.ElementType, context)));
}
case ElementType.CModOpt:
{
OptionalModifierType optionalModifierType = (OptionalModifierType)type;
return(new OptionalModifierType(this.ImportType(optionalModifierType.ModifierType, context), this.ImportType(optionalModifierType.ElementType, context)));
}
}
break;
}
}
}
throw new NotSupportedException(type.etype.ToString());
}
public ByReferenceMarshalInfoWriter(ByReferenceType type, MarshalType marshalType, MarshalInfo marshalInfo) : base(type)
{
this._elementType = type.ElementType;
this._elementTypeMarshalInfoWriter = MarshalDataCollector.MarshalInfoWriterFor(type.ElementType, marshalType, marshalInfo, false, true, false, null);
if (<>f__am$cache0 == null)
{
void doByReferenceType(ByReferenceType byReferenceType)
{
if (byReferenceTypes.ContainsKey(byReferenceType))
return;
byReferenceTypes[byReferenceType] = true;
addByReferenceType(byReferenceType);
}
private TypeReference ImportTypeSpecification(TypeReference type, ImportGenericContext context)
{
ElementType etype = type.etype;
if (etype > ElementType.CModOpt)
{
if (etype == ElementType.Sentinel)
{
SentinelType type6 = (SentinelType)type;
return(new SentinelType(this.ImportType(type6.ElementType, context)));
}
if (etype == ElementType.Pinned)
{
PinnedType type5 = (PinnedType)type;
return(new PinnedType(this.ImportType(type5.ElementType, context)));
}
}
else
{
switch (etype)
{
case ElementType.Ptr:
{
PointerType type3 = (PointerType)type;
return(new PointerType(this.ImportType(type3.ElementType, context)));
}
case ElementType.ByRef:
{
ByReferenceType type4 = (ByReferenceType)type;
return(new ByReferenceType(this.ImportType(type4.ElementType, context)));
}
case ElementType.ValueType:
case ElementType.Class:
break;
case ElementType.Var:
{
GenericParameter parameter = (GenericParameter)type;
if (parameter.DeclaringType == null)
{
throw new InvalidOperationException();
}
return(context.TypeParameter(parameter.DeclaringType.FullName, parameter.Position));
}
case ElementType.Array:
{
ArrayType type9 = (ArrayType)type;
ArrayType type10 = new ArrayType(this.ImportType(type9.ElementType, context));
if (!type9.IsVector)
{
Collection <ArrayDimension> dimensions = type9.Dimensions;
Collection <ArrayDimension> collection2 = type10.Dimensions;
collection2.Clear();
for (int i = 0; i < dimensions.Count; i++)
{
ArrayDimension dimension = dimensions[i];
collection2.Add(new ArrayDimension(dimension.LowerBound, dimension.UpperBound));
}
}
return(type10);
}
case ElementType.GenericInst:
{
GenericInstanceType type11 = (GenericInstanceType)type;
GenericInstanceType type12 = new GenericInstanceType(this.ImportType(type11.ElementType, context));
Collection <TypeReference> genericArguments = type11.GenericArguments;
Collection <TypeReference> collection4 = type12.GenericArguments;
for (int i = 0; i < genericArguments.Count; i++)
{
collection4.Add(this.ImportType(genericArguments[i], context));
}
return(type12);
}
default:
switch (etype)
{
case ElementType.SzArray:
{
ArrayType type2 = (ArrayType)type;
return(new ArrayType(this.ImportType(type2.ElementType, context)));
}
case ElementType.MVar:
{
GenericParameter parameter2 = (GenericParameter)type;
if (parameter2.DeclaringMethod == null)
{
throw new InvalidOperationException();
}
return(context.MethodParameter(parameter2.DeclaringMethod.Name, parameter2.Position));
}
case ElementType.CModReqD:
{
RequiredModifierType type8 = (RequiredModifierType)type;
return(new RequiredModifierType(this.ImportType(type8.ModifierType, context), this.ImportType(type8.ElementType, context)));
}
case ElementType.CModOpt:
{
OptionalModifierType type7 = (OptionalModifierType)type;
return(new OptionalModifierType(this.ImportType(type7.ModifierType, context), this.ImportType(type7.ElementType, context)));
}
default:
break;
}
break;
}
}
throw new NotSupportedException(type.etype.ToString());
}
static void AppendTypeName(StringBuilder b, TypeReference type)
{
if (type == null)
{
// could happen when a TypeSpecification has no ElementType; e.g. function pointers in C++/CLI assemblies
return;
}
if (type is GenericInstanceType)
{
GenericInstanceType giType = (GenericInstanceType)type;
AppendTypeNameWithArguments(b, giType.ElementType, giType.GenericArguments);
}
else if (type is TypeSpecification)
{
AppendTypeName(b, ((TypeSpecification)type).ElementType);
ArrayType arrayType = type as ArrayType;
if (arrayType != null)
{
b.Append('[');
for (int i = 0; i < arrayType.Dimensions.Count; i++)
{
if (i > 0)
{
b.Append(',');
}
ArrayDimension ad = arrayType.Dimensions[i];
if (ad.IsSized)
{
b.Append(ad.LowerBound);
b.Append(':');
b.Append(ad.UpperBound);
}
}
b.Append(']');
}
ByReferenceType refType = type as ByReferenceType;
if (refType != null)
{
b.Append('@');
}
PointerType ptrType = type as PointerType;
if (ptrType != null)
{
b.Append('*');
}
}
else
{
GenericParameter gp = type as GenericParameter;
if (gp != null)
{
b.Append('`');
if (gp.Owner.GenericParameterType == GenericParameterType.Method)
{
b.Append('`');
}
b.Append(gp.Position);
}
else if (type.DeclaringType != null)
{
AppendTypeName(b, type.DeclaringType);
b.Append('.');
b.Append(type.Name);
}
else
{
b.Append(type.FullName);
}
}
}
public JSNewExpression NewElementReference(JSExpression target, JSExpression index)
{
var resultType = new ByReferenceType(
target.GetActualType(TypeSystem).GetElementType()
);
return new JSNewExpression(
Dot("MemberReference", resultType),
null, null, target, index
);
}
private TypeReference ParseTypeReference()
{
TypeReference tr = ClassEditHelper.ParseTypeReference(cboType.SelectedItem, _method.Module);
if (tr == null)
tr = ClassEditHelper.ParseTypeReference(cboType.Text.Trim(), _method.Module);
if (tr != null)
{
switch (cboSpecification.SelectedItem as string)
{
case "Array":
tr = new ArrayType(tr);
break;
case "Reference":
tr = new ByReferenceType(tr);
break;
case "Pointer":
tr = new PointerType(tr);
break;
default:
break;
}
}
return tr;
}
public JSNewExpression NewReference(JSExpression initialValue)
{
var resultType = new ByReferenceType(initialValue.GetActualType(TypeSystem));
return new JSNewExpression(
Dot("Variable", resultType),
null, null, initialValue
);
}
private TypeReference ResolveGenericType(TypeReference originalType, IList<TypeReference> instanceArgs, IList<TypeReference> methodArgs)
{
TypeReference resolvedType = originalType;
// if generic instance, copy generic arguments by recursing into them and building a 'resolved' argument list
if (originalType is GenericInstanceType)
{
var originalGeneric = originalType as GenericInstanceType;
var resolvedGeneric = new GenericInstanceType(originalGeneric.ElementType);
resolvedType = resolvedGeneric;
foreach (var originalArg in originalGeneric.GenericArguments)
resolvedGeneric.GenericArguments.Add(
ResolveGenericType(originalArg, instanceArgs, methodArgs));
}
// if parameter, resolve it using the instance/method generice mapping lists
else if (originalType is GenericParameter)
{
var originalParam = originalType as GenericParameter;
if (originalParam.Type == GenericParameterType.Type)
resolvedType = instanceArgs[originalParam.Position];
else if (originalParam.Type == GenericParameterType.Method)
resolvedType = methodArgs[originalParam.Position];
}
else if (originalType is ArrayType)
{
var originalArray = originalType as ArrayType;
resolvedType = new ArrayType(ResolveGenericType(originalArray.ElementType, instanceArgs, methodArgs));
}
else if (originalType is ByReferenceType)
{
var originalByRef = originalType as ByReferenceType;
resolvedType = new ByReferenceType(ResolveGenericType(originalByRef.ElementType, instanceArgs, methodArgs));
}
return resolvedType;
}
private TypeReference ProcessTypeReference(TypeReference type, IGenericParameterProvider owner)
{
if (type == null)
return null;
// ref types
if (type is ByReferenceType)
{
var elementType = ProcessTypeReference(type.GetElementType(), owner);
if (elementType != type.GetElementType())
type = new ByReferenceType(elementType);
return type;
}
// Generic MVar/Var
if (type is GenericParameter)
{
var genericParameter = (GenericParameter)type;
if ((genericParameter.MetadataType == MetadataType.MVar
|| genericParameter.MetadataType == MetadataType.Var) && genericParameter.Owner is MethodReference)
{
if (genericParameter.Owner != null && owner != null)
{
return owner.GenericParameters.Concat(genericParameter.Owner.GenericParameters).First(x => x.Name == type.Name);
}
}
return type;
}
// Is it an async-related type?
var asyncBridgeType = asyncBridgeAssembly.MainModule.GetTypeResolved(type.Namespace, type.Name);
if (asyncBridgeType == null)
return type;
// First work on inner TypeReference if there is a GenericInstanceType around it.
var genericInstanceType = type as GenericInstanceType;
if (genericInstanceType != null)
{
type = genericInstanceType.ElementType;
}
var newType = assembly.MainModule.Import(new TypeReference(type.Namespace, type.Name, asyncBridgeAssembly.MainModule, asyncBridgeAssembly.Name, type.IsValueType));
for (int i = 0; i < type.GenericParameters.Count; ++i)
{
newType.GenericParameters.Add(new GenericParameter(type.GenericParameters[i].Name, newType));
foreach (var constraint in type.GenericParameters[i].Constraints)
newType.GenericParameters[i].Constraints.Add(ProcessTypeReference(constraint, newType));
}
if (genericInstanceType != null)
{
var newGenericType = new GenericInstanceType(newType);
foreach (var genericArgument in genericInstanceType.GenericArguments)
{
newGenericType.GenericArguments.Add(ProcessTypeReference(genericArgument, newGenericType));
}
newType = newGenericType;
}
return newType;
}
void addByReferenceType(ByReferenceType brt)
{
if (brt == null)
return;
addTypeSpecification(brt);
}
TypeReference DoInferTypeForExpression(ILExpression expr, TypeReference expectedType, bool forceInferChildren = false)
{
switch (expr.Code) {
#region Logical operators
case ILCode.LogicNot:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments.Single(), typeSystem.Boolean);
}
return typeSystem.Boolean;
case ILCode.LogicAnd:
case ILCode.LogicOr:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], typeSystem.Boolean);
InferTypeForExpression(expr.Arguments[1], typeSystem.Boolean);
}
return typeSystem.Boolean;
case ILCode.TernaryOp:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], typeSystem.Boolean);
}
return TypeWithMoreInformation(
InferTypeForExpression(expr.Arguments[1], expectedType, forceInferChildren),
InferTypeForExpression(expr.Arguments[2], expectedType, forceInferChildren)
);
case ILCode.NullCoalescing:
return TypeWithMoreInformation(
InferTypeForExpression(expr.Arguments[0], expectedType, forceInferChildren),
InferTypeForExpression(expr.Arguments[1], expectedType, forceInferChildren)
);
#endregion
#region Variable load/store
case ILCode.Stloc:
{
ILVariable v = (ILVariable)expr.Operand;
if (forceInferChildren) {
// do not use 'expectedType' in here!
InferTypeForExpression(expr.Arguments.Single(), v.Type);
}
return v.Type;
}
case ILCode.Ldloc:
{
ILVariable v = (ILVariable)expr.Operand;
if (v.Type == null && singleLoadVariables.Contains(v)) {
v.Type = expectedType;
}
return v.Type;
}
case ILCode.Ldloca:
return new ByReferenceType(((ILVariable)expr.Operand).Type);
#endregion
#region Call / NewObj
case ILCode.Call:
case ILCode.Callvirt:
case ILCode.CallGetter:
case ILCode.CallvirtGetter:
case ILCode.CallSetter:
case ILCode.CallvirtSetter:
{
MethodReference method = (MethodReference)expr.Operand;
if (forceInferChildren) {
for (int i = 0; i < expr.Arguments.Count; i++) {
if (i == 0 && method.HasThis) {
ILExpressionPrefix constraint = expr.GetPrefix(ILCode.Constrained);
if (constraint != null)
InferTypeForExpression(expr.Arguments[i], new ByReferenceType((TypeReference)constraint.Operand));
else if (method.DeclaringType.IsValueType)
InferTypeForExpression(expr.Arguments[i], new ByReferenceType(method.DeclaringType));
else
InferTypeForExpression(expr.Arguments[i], method.DeclaringType);
} else {
InferTypeForExpression(expr.Arguments[i], SubstituteTypeArgs(method.Parameters[method.HasThis ? i - 1 : i].ParameterType, method));
}
}
}
if (expr.Code == ILCode.CallSetter || expr.Code == ILCode.CallvirtSetter) {
return SubstituteTypeArgs(method.Parameters.Last().ParameterType, method);
} else {
TypeReference type = SubstituteTypeArgs(method.ReturnType, method);
if (expr.GetPrefix(ILCode.PropertyAddress) != null && !(type is ByReferenceType))
type = new ByReferenceType(type);
return type;
}
}
case ILCode.Newobj:
{
MethodReference ctor = (MethodReference)expr.Operand;
if (forceInferChildren) {
for (int i = 0; i < ctor.Parameters.Count; i++) {
InferTypeForExpression(expr.Arguments[i], SubstituteTypeArgs(ctor.Parameters[i].ParameterType, ctor));
}
}
return ctor.DeclaringType;
}
case ILCode.InitCollection:
return InferTypeForExpression(expr.Arguments[0], expectedType);
case ILCode.InitCollectionAddMethod:
{
MethodReference addMethod = (MethodReference)expr.Operand;
if (forceInferChildren) {
for (int i = 1; i < addMethod.Parameters.Count; i++) {
InferTypeForExpression(expr.Arguments[i-1], SubstituteTypeArgs(addMethod.Parameters[i].ParameterType, addMethod));
}
}
return addMethod.DeclaringType;
}
#endregion
#region Load/Store Fields
case ILCode.Ldfld:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments[0], ((FieldReference)expr.Operand).DeclaringType);
return GetFieldType((FieldReference)expr.Operand);
case ILCode.Ldsfld:
return GetFieldType((FieldReference)expr.Operand);
case ILCode.Ldflda:
case ILCode.Ldsflda:
return new ByReferenceType(GetFieldType((FieldReference)expr.Operand));
case ILCode.Stfld:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], ((FieldReference)expr.Operand).DeclaringType);
InferTypeForExpression(expr.Arguments[1], GetFieldType((FieldReference)expr.Operand));
}
return GetFieldType((FieldReference)expr.Operand);
case ILCode.Stsfld:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments[0], GetFieldType((FieldReference)expr.Operand));
return GetFieldType((FieldReference)expr.Operand);
#endregion
#region Reference/Pointer instructions
case ILCode.Ldind_Ref:
return UnpackPointer(InferTypeForExpression(expr.Arguments[0], null));
case ILCode.Stind_Ref:
if (forceInferChildren) {
TypeReference elementType = UnpackPointer(InferTypeForExpression(expr.Arguments[0], null));
InferTypeForExpression(expr.Arguments[1], elementType);
}
return null;
case ILCode.Ldobj:
{
TypeReference type = (TypeReference)expr.Operand;
if (expectedType != null) {
int infoAmount = GetInformationAmount(expectedType);
if (infoAmount == 1 && GetInformationAmount(type) == 8) {
// A bool can be loaded from both bytes and sbytes.
type = expectedType;
}
if (infoAmount >= 8 && infoAmount <= 64 && infoAmount == GetInformationAmount(type)) {
// An integer can be loaded as another integer of the same size.
// For integers smaller than 32 bit, the signs must match (as loading performs sign extension)
if (infoAmount >= 32 || IsSigned(expectedType) == IsSigned(type))
type = expectedType;
}
}
if (forceInferChildren) {
if (InferTypeForExpression(expr.Arguments[0], new ByReferenceType(type)) is PointerType)
InferTypeForExpression(expr.Arguments[0], new PointerType(type));
}
return type;
}
case ILCode.Stobj:
{
TypeReference operandType = (TypeReference)expr.Operand;
TypeReference pointerType = InferTypeForExpression(expr.Arguments[0], new ByReferenceType(operandType));
TypeReference elementType;
if (pointerType is PointerType)
elementType = ((PointerType)pointerType).ElementType;
else if (pointerType is ByReferenceType)
elementType = ((ByReferenceType)pointerType).ElementType;
else
elementType = null;
if (elementType != null) {
// An integer can be stored in any other integer of the same size.
int infoAmount = GetInformationAmount(elementType);
if (infoAmount == 1 && GetInformationAmount(operandType) == 8)
operandType = elementType;
else if (infoAmount == GetInformationAmount(operandType) && IsSigned(elementType) != null && IsSigned(operandType) != null)
operandType = elementType;
}
if (forceInferChildren) {
if (pointerType is PointerType)
InferTypeForExpression(expr.Arguments[0], new PointerType(operandType));
else if (!IsSameType(operandType, expr.Operand as TypeReference))
InferTypeForExpression(expr.Arguments[0], new ByReferenceType(operandType));
InferTypeForExpression(expr.Arguments[1], operandType);
}
return operandType;
}
case ILCode.Initobj:
return null;
case ILCode.DefaultValue:
return (TypeReference)expr.Operand;
case ILCode.Localloc:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], typeSystem.Int32);
}
if (expectedType is PointerType)
return expectedType;
else
return typeSystem.IntPtr;
case ILCode.Sizeof:
return typeSystem.Int32;
case ILCode.PostIncrement:
case ILCode.PostIncrement_Ovf:
case ILCode.PostIncrement_Ovf_Un:
{
TypeReference elementType = UnpackPointer(InferTypeForExpression(expr.Arguments[0], null));
if (forceInferChildren && elementType != null) {
// Assign expected type to the child expression
InferTypeForExpression(expr.Arguments[0], new ByReferenceType(elementType));
}
return elementType;
}
#endregion
#region Arithmetic instructions
case ILCode.Not: // bitwise complement
case ILCode.Neg:
return InferTypeForExpression(expr.Arguments.Single(), expectedType);
case ILCode.Add:
return InferArgumentsInAddition(expr, null, expectedType);
case ILCode.Sub:
return InferArgumentsInSubtraction(expr, null, expectedType);
case ILCode.Mul:
case ILCode.Or:
case ILCode.And:
case ILCode.Xor:
return InferArgumentsInBinaryOperator(expr, null, expectedType);
case ILCode.Add_Ovf:
return InferArgumentsInAddition(expr, true, expectedType);
case ILCode.Sub_Ovf:
return InferArgumentsInSubtraction(expr, true, expectedType);
case ILCode.Mul_Ovf:
case ILCode.Div:
case ILCode.Rem:
return InferArgumentsInBinaryOperator(expr, true, expectedType);
case ILCode.Add_Ovf_Un:
return InferArgumentsInAddition(expr, false, expectedType);
case ILCode.Sub_Ovf_Un:
return InferArgumentsInSubtraction(expr, false, expectedType);
case ILCode.Mul_Ovf_Un:
case ILCode.Div_Un:
case ILCode.Rem_Un:
return InferArgumentsInBinaryOperator(expr, false, expectedType);
case ILCode.Shl:
case ILCode.Shr:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
return InferTypeForExpression(expr.Arguments[0], typeSystem.Int32);
case ILCode.Shr_Un:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
return InferTypeForExpression(expr.Arguments[0], typeSystem.UInt32);
case ILCode.CompoundAssignment:
{
TypeReference varType = InferTypeForExpression(expr.Arguments[0].Arguments[0], null);
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], varType);
}
return varType;
}
#endregion
#region Constant loading instructions
case ILCode.Ldnull:
return typeSystem.Object;
case ILCode.Ldstr:
return typeSystem.String;
case ILCode.Ldftn:
case ILCode.Ldvirtftn:
return typeSystem.IntPtr;
case ILCode.Ldc_I4:
if (IsBoolean(expectedType) && ((int)expr.Operand == 0 || (int)expr.Operand == 1))
return typeSystem.Boolean;
return (IsIntegerOrEnum(expectedType) || expectedType is PointerType) ? expectedType : typeSystem.Int32;
case ILCode.Ldc_I8:
return (IsIntegerOrEnum(expectedType) || expectedType is PointerType) ? expectedType : typeSystem.Int64;
case ILCode.Ldc_R4:
return typeSystem.Single;
case ILCode.Ldc_R8:
return typeSystem.Double;
case ILCode.Ldc_Decimal:
return new TypeReference("System", "Decimal", module, module, true);
case ILCode.Ldtoken:
if (expr.Operand is TypeReference)
return new TypeReference("System", "RuntimeTypeHandle", module, module, true);
else if (expr.Operand is FieldReference)
return new TypeReference("System", "RuntimeFieldHandle", module, module, true);
else
return new TypeReference("System", "RuntimeMethodHandle", module, module, true);
case ILCode.Arglist:
return new TypeReference("System", "RuntimeArgumentHandle", module, module, true);
#endregion
#region Array instructions
case ILCode.Newarr:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments.Single(), typeSystem.Int32);
return new ArrayType((TypeReference)expr.Operand);
case ILCode.InitArray:
if (forceInferChildren) {
foreach (ILExpression arg in expr.Arguments)
InferTypeForExpression(arg, (TypeReference)expr.Operand);
}
return new ArrayType((TypeReference)expr.Operand);
case ILCode.Ldlen:
return typeSystem.Int32;
case ILCode.Ldelem_U1:
case ILCode.Ldelem_U2:
case ILCode.Ldelem_U4:
case ILCode.Ldelem_I1:
case ILCode.Ldelem_I2:
case ILCode.Ldelem_I4:
case ILCode.Ldelem_I8:
case ILCode.Ldelem_R4:
case ILCode.Ldelem_R8:
case ILCode.Ldelem_I:
case ILCode.Ldelem_Ref:
{
ArrayType arrayType = InferTypeForExpression(expr.Arguments[0], null) as ArrayType;
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
}
return arrayType != null ? arrayType.ElementType : null;
}
case ILCode.Ldelem_Any:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
}
return (TypeReference)expr.Operand;
case ILCode.Ldelema:
{
ArrayType arrayType = InferTypeForExpression(expr.Arguments[0], null) as ArrayType;
if (forceInferChildren)
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
return arrayType != null ? new ByReferenceType(arrayType.ElementType) : null;
}
case ILCode.Stelem_I:
case ILCode.Stelem_I1:
case ILCode.Stelem_I2:
case ILCode.Stelem_I4:
case ILCode.Stelem_I8:
case ILCode.Stelem_R4:
case ILCode.Stelem_R8:
case ILCode.Stelem_Ref:
case ILCode.Stelem_Any:
{
ArrayType arrayType = InferTypeForExpression(expr.Arguments[0], null) as ArrayType;
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[1], typeSystem.Int32);
if (arrayType != null) {
InferTypeForExpression(expr.Arguments[2], arrayType.ElementType);
}
}
return arrayType != null ? arrayType.ElementType : null;
}
#endregion
#region Conversion instructions
case ILCode.Conv_I1:
case ILCode.Conv_Ovf_I1:
case ILCode.Conv_Ovf_I1_Un:
return HandleConversion(8, true, expr.Arguments[0], expectedType, typeSystem.SByte);
case ILCode.Conv_I2:
case ILCode.Conv_Ovf_I2:
case ILCode.Conv_Ovf_I2_Un:
return HandleConversion(16, true, expr.Arguments[0], expectedType, typeSystem.Int16);
case ILCode.Conv_I4:
case ILCode.Conv_Ovf_I4:
case ILCode.Conv_Ovf_I4_Un:
return HandleConversion(32, true, expr.Arguments[0], expectedType, typeSystem.Int32);
case ILCode.Conv_I8:
case ILCode.Conv_Ovf_I8:
case ILCode.Conv_Ovf_I8_Un:
return HandleConversion(64, true, expr.Arguments[0], expectedType, typeSystem.Int64);
case ILCode.Conv_U1:
case ILCode.Conv_Ovf_U1:
case ILCode.Conv_Ovf_U1_Un:
return HandleConversion(8, false, expr.Arguments[0], expectedType, typeSystem.Byte);
case ILCode.Conv_U2:
case ILCode.Conv_Ovf_U2:
case ILCode.Conv_Ovf_U2_Un:
return HandleConversion(16, false, expr.Arguments[0], expectedType, typeSystem.UInt16);
case ILCode.Conv_U4:
case ILCode.Conv_Ovf_U4:
case ILCode.Conv_Ovf_U4_Un:
return HandleConversion(32, false, expr.Arguments[0], expectedType, typeSystem.UInt32);
case ILCode.Conv_U8:
case ILCode.Conv_Ovf_U8:
case ILCode.Conv_Ovf_U8_Un:
return HandleConversion(64, false, expr.Arguments[0], expectedType, typeSystem.UInt64);
case ILCode.Conv_I:
case ILCode.Conv_Ovf_I:
case ILCode.Conv_Ovf_I_Un:
return HandleConversion(NativeInt, true, expr.Arguments[0], expectedType, typeSystem.IntPtr);
case ILCode.Conv_U:
case ILCode.Conv_Ovf_U:
case ILCode.Conv_Ovf_U_Un:
return HandleConversion(NativeInt, false, expr.Arguments[0], expectedType, typeSystem.UIntPtr);
case ILCode.Conv_R4:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], typeSystem.Single);
}
return typeSystem.Single;
case ILCode.Conv_R8:
if (forceInferChildren) {
InferTypeForExpression(expr.Arguments[0], typeSystem.Double);
}
return typeSystem.Double;
case ILCode.Conv_R_Un:
return (expectedType != null && expectedType.MetadataType == MetadataType.Single) ? typeSystem.Single : typeSystem.Double;
case ILCode.Castclass:
case ILCode.Isinst:
case ILCode.Unbox_Any:
return (TypeReference)expr.Operand;
case ILCode.Box:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments.Single(), (TypeReference)expr.Operand);
return (TypeReference)expr.Operand;
#endregion
#region Comparison instructions
case ILCode.Ceq:
if (forceInferChildren)
InferArgumentsInBinaryOperator(expr, null, null);
return typeSystem.Boolean;
case ILCode.Clt:
case ILCode.Cgt:
if (forceInferChildren)
InferArgumentsInBinaryOperator(expr, true, null);
return typeSystem.Boolean;
case ILCode.Clt_Un:
case ILCode.Cgt_Un:
if (forceInferChildren)
InferArgumentsInBinaryOperator(expr, false, null);
return typeSystem.Boolean;
#endregion
#region Branch instructions
case ILCode.Brtrue:
if (forceInferChildren)
InferTypeForExpression(expr.Arguments.Single(), typeSystem.Boolean);
return null;
case ILCode.Br:
case ILCode.Leave:
case ILCode.Endfinally:
case ILCode.Switch:
case ILCode.Throw:
case ILCode.Rethrow:
case ILCode.LoopOrSwitchBreak:
case ILCode.LoopContinue:
case ILCode.YieldBreak:
return null;
case ILCode.Ret:
if (forceInferChildren && expr.Arguments.Count == 1)
InferTypeForExpression(expr.Arguments[0], context.CurrentMethod.ReturnType);
return null;
case ILCode.YieldReturn:
if (forceInferChildren) {
GenericInstanceType genericType = context.CurrentMethod.ReturnType as GenericInstanceType;
if (genericType != null) { // IEnumerable<T> or IEnumerator<T>
InferTypeForExpression(expr.Arguments[0], genericType.GenericArguments[0]);
} else { // non-generic IEnumerable or IEnumerator
InferTypeForExpression(expr.Arguments[0], typeSystem.Object);
}
}
return null;
#endregion
case ILCode.Pop:
return null;
case ILCode.Dup:
return InferTypeForExpression(expr.Arguments.Single(), expectedType);
default:
Debug.WriteLine("Type Inference: Can't handle " + expr.Code.GetName());
return null;
}
}
private StaticByRefTypeWrapper MakeByRefType(ByReferenceType referenceTypeHandle)
{
return MakeType(referenceTypeHandle.ElementType).MakeByRefType();
}
protected override bool VerifyIsConstrainedToNSObject(TypeReference type, out TypeReference constrained_type)
{
constrained_type = null;
var gp = type as GenericParameter;
if (gp != null) {
if (!gp.HasConstraints)
return false;
foreach (var c in gp.Constraints) {
if (IsNSObject (c)) {
constrained_type = c;
return true;
}
}
return false;
}
var git = type as GenericInstanceType;
if (git != null) {
var rv = true;
if (git.HasGenericArguments) {
var newGit = new GenericInstanceType (git.ElementType);
for (int i = 0; i < git.GenericArguments.Count; i++) {
TypeReference constr;
rv &= VerifyIsConstrainedToNSObject (git.GenericArguments [i], out constr);
newGit.GenericArguments.Add (constr ?? git.GenericArguments [i]);
}
constrained_type = newGit;
}
return rv;
}
var el = type as ArrayType;
if (el != null) {
var rv = VerifyIsConstrainedToNSObject (el.ElementType, out constrained_type);
if (constrained_type == null)
return rv;
constrained_type = new ArrayType (constrained_type, el.Rank);
return rv;
}
var rt = type as ByReferenceType;
if (rt != null) {
var rv = VerifyIsConstrainedToNSObject (rt.ElementType, out constrained_type);
if (constrained_type == null)
return rv;
constrained_type = new ByReferenceType (constrained_type);
return rv;
}
var tr = type as PointerType;
if (tr != null) {
var rv = VerifyIsConstrainedToNSObject (tr.ElementType, out constrained_type);
if (constrained_type == null)
return rv;
constrained_type = new PointerType (constrained_type);
return rv;
}
return true;
}
protected virtual ByReferenceType updateByReferenceType(ByReferenceType a)
{
return new ByReferenceType(update(a.ElementType));
}
void doByReferenceType(ByReferenceType byReferenceType)
{
bool present;
if (byReferenceTypes.TryGetValue(byReferenceType, out present))
return;
byReferenceTypes[byReferenceType] = true;
addByReferenceType(byReferenceType);
}
static int byReferenceTypeHashCode(ByReferenceType a)
{
if (a == null)
return 0;
return typeSpecificationHashCode(a);
}
public static ByReferenceType ChangeByReferenceType(this ByReferenceType type, TypeReference elementType)
{
if (elementType != type.ElementType)
{
var result = new ByReferenceType(elementType);
if (type.HasGenericParameters)
SetGenericParameters(result, type.GenericParameters);
return result;
}
return type;
}
private static ByReferenceType ResolveIfNeeded(IGenericInstance genericInstanceMethod, IGenericInstance genericInstanceType, ByReferenceType byReferenceType)
{
return new ByReferenceType(ResolveIfNeeded(genericInstanceMethod, genericInstanceType, byReferenceType.ElementType));
}