/// <summary>
/// Add the given field to its declaring class.
/// </summary>
protected override void AddFieldToDeclaringClass(ClassDefinition declaringClass, DexLib.FieldDefinition dfield, DexTargetPackage targetPackage)
{
var generatedCodeClass = targetPackage.GetOrCreateGeneratedCodeClass();
UpdateName(dfield, generatedCodeClass);
dfield.Owner = generatedCodeClass;
generatedCodeClass.Fields.Add(dfield);
}
/// <summary>
/// Add the given method to its declaring class.
/// </summary>
protected override void AddMethodToDeclaringClass(ClassDefinition declaringClass, DexLib.MethodDefinition dmethod, DexTargetPackage targetPackage)
{
var generatedCodeClass = targetPackage.GetOrCreateGeneratedCodeClass();
UpdateName(dmethod, generatedCodeClass);
dmethod.Owner = generatedCodeClass;
generatedCodeClass.Methods.Add(dmethod);
}
/// <summary>
/// Add the given method to its declaring class.
/// </summary>
protected override void AddMethodToDeclaringClass(ClassDefinition declaringClass, DexLib.MethodDefinition dmethod, DexTargetPackage targetPackage)
{
var generatedCodeClass = targetPackage.GetOrCreateGeneratedCodeClass();
UpdateName(dmethod, generatedCodeClass);
dmethod.Owner = generatedCodeClass;
generatedCodeClass.Methods.Add(dmethod);
}
/// <summary>
/// Add the given field to its declaring class.
/// </summary>
protected override void AddFieldToDeclaringClass(ClassDefinition declaringClass, DexLib.FieldDefinition dfield, DexTargetPackage targetPackage)
{
var generatedCodeClass = targetPackage.GetOrCreateGeneratedCodeClass();
UpdateName(dfield, generatedCodeClass);
dfield.Owner = generatedCodeClass;
generatedCodeClass.Fields.Add(dfield);
}
/// <summary>
/// Create the current type as class definition.
/// </summary>
internal static DelegateInstanceType Create(
ISourceLocation sequencePoint,
AssemblyCompiler compiler,
DexTargetPackage targetPackage,
ClassDefinition delegateClass,
XMethodDefinition invokeMethod,
Prototype invokePrototype,
XMethodDefinition equalsMethod,
Prototype equalsPrototype,
XMethodDefinition calledMethod)
{
// Prepare called method
var target = targetPackage.DexFile;
var owner = target.GetClass(calledMethod.DeclaringType.GetClassReference(targetPackage).Fullname) ??
targetPackage.GetOrCreateGeneratedCodeClass();
var calledMethodPrototype = PrototypeBuilder.BuildPrototype(compiler, targetPackage, owner, calledMethod);
var calledMethodRef = calledMethod.GetReference(targetPackage);
if (calledMethod.DeclaringType.HasDexImportAttribute())
{
// Delegate method is a Dex import method
}
else
{
// Delegate method is a .NET method
var calledDexMethod = owner.Methods.Single(x => (x.Name == calledMethodRef.Name) && (x.Prototype.Equals(calledMethodRef.Prototype)));
if (calledDexMethod.IsPrivate)
{
calledDexMethod.IsPrivate = false;
calledDexMethod.IsProtected = true;
}
}
var @class = new ClassDefinition();
@class.Name = CreateInstanceTypeName(owner);
@class.Namespace = owner.Namespace;
@class.AccessFlags = AccessFlags.Public | AccessFlags.Final;
owner.InnerClasses.Add(@class);
// Set super class
@class.SuperClass = delegateClass;
// Implement delegate interface
//@class.Interfaces.Add(delegateInterface);
// Get type of instance
XTypeDefinition instanceType = calledMethod.DeclaringType;
TypeReference instanceTypeRef = instanceType.GetReference(targetPackage);
// Add instance field
FieldDefinition instanceField = null;
if (!calledMethod.IsStatic)
{
instanceField = new FieldDefinition();
instanceField.Name = "instance";
instanceField.Owner = @class;
instanceField.Type = instanceTypeRef;
instanceField.AccessFlags = AccessFlags.Private | AccessFlags.Final;
@class.Fields.Add(instanceField);
}
// Add ctor
var ctor = new Dot42.DexLib.MethodDefinition();
ctor.Owner = @class;
ctor.Name = "<init>";
ctor.AccessFlags = AccessFlags.Public | AccessFlags.Constructor;
ctor.Prototype = new Prototype(PrimitiveType.Void);
if (!calledMethod.IsStatic)
{
ctor.Prototype.Parameters.Add(new Parameter(instanceTypeRef, "this"));
}
@class.Methods.Add(ctor);
// Create ctor body
var ctorBody = CreateCtorBody(calledMethod, instanceField, delegateClass);
targetPackage.Record(new CompiledMethod() { DexMethod = ctor, RLBody = ctorBody });
// Add Invoke method
var invoke = new Dot42.DexLib.MethodDefinition(@class, "Invoke", invokePrototype) { AccessFlags = AccessFlags.Public };
@class.Methods.Add(invoke);
// Create body
var invokeBody = CreateInvokeBody(sequencePoint, compiler, targetPackage, calledMethod, invokeMethod, invokePrototype, calledMethodPrototype, instanceField, delegateClass);
targetPackage.Record(new CompiledMethod() { DexMethod = invoke, RLBody = invokeBody });
// Add Equals method
if (null != equalsMethod)
{
var equals = new Dot42.DexLib.MethodDefinition(@class, "equals", equalsPrototype) { AccessFlags = AccessFlags.Public };
@class.Methods.Add(equals);
// Create body
if (!calledMethod.IsStatic)
{
var equalsBody = CreateEqualsBody(sequencePoint, compiler, targetPackage, equalsMethod, equalsPrototype, instanceField, @class);
targetPackage.Record(new CompiledMethod() { DexMethod = equals, RLBody = equalsBody });
}
else
{
var equalsBody = CreateEqualsBody();
targetPackage.Record(new CompiledMethod() { DexMethod = equals, RLBody = equalsBody });
}
}
return new DelegateInstanceType(calledMethod, @class, ctor);
}
/// <summary>
/// Create the current type as class definition.
/// </summary>
internal static DelegateInstanceType Create(
ISourceLocation sequencePoint,
AssemblyCompiler compiler,
DexTargetPackage targetPackage,
ClassDefinition delegateClass,
XMethodDefinition invokeMethod,
Prototype invokePrototype,
XMethodDefinition equalsMethod,
Prototype equalsPrototype,
XMethodDefinition calledMethod)
{
// Prepare called method
var target = targetPackage.DexFile;
var owner = target.GetClass(calledMethod.DeclaringType.GetClassReference(targetPackage).Fullname) ??
targetPackage.GetOrCreateGeneratedCodeClass();
var calledMethodPrototype = PrototypeBuilder.BuildPrototype(compiler, targetPackage, owner, calledMethod);
var calledMethodRef = calledMethod.GetReference(targetPackage);
if (calledMethod.DeclaringType.HasDexImportAttribute())
{
// Delegate method is a Dex import method
}
else
{
// Delegate method is a .NET method
var calledDexMethod = owner.Methods.Single(x => (x.Name == calledMethodRef.Name) && (x.Prototype.Equals(calledMethodRef.Prototype)));
if (calledDexMethod.IsPrivate)
{
calledDexMethod.IsPrivate = false;
calledDexMethod.IsProtected = true;
}
}
var @class = new ClassDefinition();
@class.Name = CreateInstanceTypeName(owner);
@class.Namespace = owner.Namespace;
@class.AccessFlags = AccessFlags.Public | AccessFlags.Final;
owner.InnerClasses.Add(@class);
// Set super class
@class.SuperClass = delegateClass;
// Implement delegate interface
//@class.Interfaces.Add(delegateInterface);
// Get type of instance
XTypeDefinition instanceType = calledMethod.DeclaringType;
TypeReference instanceTypeRef = instanceType.GetReference(targetPackage);
// Add instance field
FieldDefinition instanceField = null;
if (!calledMethod.IsStatic)
{
instanceField = new FieldDefinition();
instanceField.Name = "instance";
instanceField.Owner = @class;
instanceField.Type = instanceTypeRef;
instanceField.AccessFlags = AccessFlags.Private | AccessFlags.Final;
@class.Fields.Add(instanceField);
}
// Add ctor
var ctor = new Dot42.DexLib.MethodDefinition();
ctor.Owner = @class;
ctor.Name = "<init>";
ctor.AccessFlags = AccessFlags.Public | AccessFlags.Constructor;
ctor.Prototype = new Prototype(PrimitiveType.Void);
if (!calledMethod.IsStatic)
{
ctor.Prototype.Parameters.Add(new Parameter(instanceTypeRef, "this"));
}
@class.Methods.Add(ctor);
// Create ctor body
var ctorBody = CreateCtorBody(calledMethod, instanceField, delegateClass);
targetPackage.Record(new CompiledMethod()
{
DexMethod = ctor, RLBody = ctorBody
});
// Add Invoke method
var invoke = new Dot42.DexLib.MethodDefinition(@class, "Invoke", invokePrototype)
{
AccessFlags = AccessFlags.Public
};
@class.Methods.Add(invoke);
// Create body
var invokeBody = CreateInvokeBody(sequencePoint, compiler, targetPackage, calledMethod, invokeMethod, invokePrototype, calledMethodPrototype, instanceField, delegateClass);
targetPackage.Record(new CompiledMethod()
{
DexMethod = invoke, RLBody = invokeBody
});
// Add Equals method
if (null != equalsMethod)
{
var equals = new Dot42.DexLib.MethodDefinition(@class, "equals", equalsPrototype)
{
AccessFlags = AccessFlags.Public
};
@class.Methods.Add(equals);
// Create body
if (!calledMethod.IsStatic)
{
var equalsBody = CreateEqualsBody(sequencePoint, compiler, targetPackage, equalsMethod, equalsPrototype, instanceField, @class);
targetPackage.Record(new CompiledMethod()
{
DexMethod = equals, RLBody = equalsBody
});
}
else
{
var equalsBody = CreateEqualsBody();
targetPackage.Record(new CompiledMethod()
{
DexMethod = equals, RLBody = equalsBody
});
}
}
return(new DelegateInstanceType(calledMethod, @class, ctor));
}
public DelegateInstanceType Create()
{
instanceField = null; // actually at the momennt, we are not called multiple times...
genericMethodTypeFields.Clear();
genericInstanceTypeFields.Clear();
// Prepare called method
var target = targetPackage.DexFile;
var owner = target.GetClass(calledMethod.DeclaringType.GetClassReference(targetPackage).Fullname)
?? targetPackage.GetOrCreateGeneratedCodeClass();
var calledMethodPrototype = PrototypeBuilder.BuildPrototype(compiler, targetPackage, owner, calledMethod);
var calledMethodRef = calledMethod.GetReference(targetPackage);
if (calledMethod.DeclaringType.HasDexImportAttribute())
{
// Delegate method is a Dex import method
}
else
{
// Delegate method is a .NET method
var calledDexMethod = owner.Methods.Single(x => (x.Name == calledMethodRef.Name) && (x.Prototype.Equals(calledMethodRef.Prototype)));
if (calledDexMethod.IsPrivate)
{
calledDexMethod.IsPrivate = false;
calledDexMethod.IsProtected = true;
}
}
var @class = new ClassDefinition
{
Name = CreateInstanceTypeName(owner),
Namespace = owner.Namespace,
AccessFlags = AccessFlags.Public | AccessFlags.Final,
MapFileId = compiler.GetNextMapFileId(),
};
owner.AddInnerClass(@class);
// Set super class
@class.SuperClass = delegateClass;
// Implement delegate interface
//@class.Interfaces.Add(delegateInterface);
// Get type of instance
XTypeDefinition instanceType = calledMethod.DeclaringType;
TypeReference instanceTypeRef = instanceType.GetReference(targetPackage);
// Add ctor
var ctor = new MethodDefinition
{
Owner = @class,
Name = "<init>",
AccessFlags = AccessFlags.Public | AccessFlags.Constructor,
Prototype = new Prototype(PrimitiveType.Void),
};
ctor.Prototype.Unfreeze();
if (!calledMethod.IsStatic)
{
ctor.Prototype.Parameters.Add(new Parameter(instanceTypeRef, "this"));
}
PrototypeBuilder.AddGenericParameters(compiler, targetPackage, calledMethod, ctor.Prototype);
ctor.Prototype.Freeze();
@class.Methods.Add(ctor);
// Add methodInfo field
methodInfoField = new FieldDefinition();
methodInfoField.Name = "methodInfo";
methodInfoField.Owner = @class;
methodInfoField.Type = compiler.GetDot42InternalType("System.Reflection", "MethodInfo").GetReference(targetPackage);
methodInfoField.AccessFlags = AccessFlags.Private | AccessFlags.Final | AccessFlags.Static;
@class.Fields.Add(methodInfoField);
// Add instance field & getTargetImpl method
if (!calledMethod.IsStatic)
{
instanceField = new FieldDefinition();
instanceField.Name = "instance";
instanceField.Owner = @class;
instanceField.Type = instanceTypeRef;
instanceField.AccessFlags = AccessFlags.Private | AccessFlags.Final;
@class.Fields.Add(instanceField);
AddMethod(@class, "GetTargetImpl", new Prototype(FrameworkReferences.Object), AccessFlags.Protected,
CreateGetTargetImplBody());
}
// Add generic instance type and method fields
var gtpa = compiler.GetDot42InternalType(InternalConstants.GenericTypeParameterAnnotation).GetClassReference(targetPackage);
var gmpa = compiler.GetDot42InternalType(InternalConstants.GenericMethodParameterAnnotation).GetClassReference(targetPackage);
foreach (var parameter in ctor.Prototype.Parameters)
{
bool isGtpa = parameter.Annotations.Any(a => a.Type.Equals(gtpa));
bool isGmpa = parameter.Annotations.Any(a => a.Type.Equals(gmpa));
if (isGmpa || isGtpa)
{
var list = isGtpa ? genericInstanceTypeFields : genericMethodTypeFields;
var field = new FieldDefinition();
field.Name = isGtpa ? "$git" : "$gmt";
if (parameter.Type.Equals(FrameworkReferences.Class))
{
field.Name += list.Count + 1;
}
field.Owner = @class;
field.Type = parameter.Type;
field.AccessFlags = AccessFlags.Private | AccessFlags.Final;
@class.Fields.Add(field);
list.Add(field);
}
}
// Create ctor body
var ctorBody = CreateCtorBody();
targetPackage.Record(new CompiledMethod()
{
DexMethod = ctor, RLBody = ctorBody
});
// add class static ctor
AddMethod(@class, "<clinit>", new Prototype(PrimitiveType.Void),
AccessFlags.Public | AccessFlags.Constructor | AccessFlags.Static,
CreateCctorBody());
// Add Invoke method
AddMethod(@class, "Invoke", invokePrototype, AccessFlags.Public, CreateInvokeBody(calledMethodPrototype));
// Add Equals method
var typeOnlyEqualsSuffices = calledMethod.IsStatic && !calledMethod.NeedsGenericInstanceTypeParameter && !calledMethod.NeedsGenericInstanceMethodParameter;
var equalsBody = typeOnlyEqualsSuffices ? CreateEqualsCheckTypeOnlyBody(@class) : CreateEqualsBody(@class);
var equalsPrototype = new Prototype(PrimitiveType.Boolean, new Parameter(multicastDelegateClass, "other"));
AddMethod(@class, "EqualsWithoutInvocationList", equalsPrototype, AccessFlags.Protected, equalsBody);
if (!typeOnlyEqualsSuffices)
{
var hashCodePrototype = new Prototype(PrimitiveType.Int);
AddMethod(@class, "HashCodeWithoutInvocationList", hashCodePrototype, AccessFlags.Protected, CreateHashCodeBody(@class));
}
var clonePrototype = new Prototype(multicastDelegateClass, new Parameter(new ArrayType(multicastDelegateClass), "invocationList"), new Parameter(PrimitiveType.Int, "invocationListLength"));
AddMethod(@class, "CloneWithNewInvocationList", clonePrototype, AccessFlags.Protected,
CreateCloneBody(ctor, @class));
AddMethod(@class, "GetMethodInfoImpl", new Prototype(methodInfoField.Type), AccessFlags.Protected,
CreateGetMethodInfoImplBody());
return(new DelegateInstanceType(calledMethod, @class, ctor));
}
