public void Run(AstNode compilationUnit)
{
foreach (InvocationExpression invocation in compilationUnit.Descendants.OfType <InvocationExpression>())
{
MemberReferenceExpression mre = invocation.Target as MemberReferenceExpression;
IMethod methodReference = invocation.Annotation <IMethod>();
if (mre != null && mre.Target is TypeReferenceExpression && methodReference != null && invocation.Arguments.Any())
{
MethodDef d = methodReference.Resolve();
if (d != null)
{
foreach (var ca in d.CustomAttributes)
{
if (ca.AttributeType != null && ca.AttributeType.Name == "ExtensionAttribute" && ca.AttributeType.Namespace == "System.Runtime.CompilerServices")
{
var firstArgument = invocation.Arguments.First();
if (firstArgument is NullReferenceExpression)
{
firstArgument = firstArgument.ReplaceWith(expr => expr.CastTo(AstBuilder.ConvertType(d.Parameters.SkipNonNormal().First().Type)));
}
else
{
var ilRanges = mre.Target.GetAllRecursiveILRanges();
mre.Target = firstArgument.Detach();
if (ilRanges.Count > 0)
{
mre.Target.AddAnnotation(ilRanges);
}
}
if (invocation.Arguments.Any())
{
// HACK: removing type arguments should be done indepently from whether a method is an extension method,
// just by testing whether the arguments can be inferred
var ilRanges = mre.TypeArguments.GetAllRecursiveILRanges();
mre.TypeArguments.Clear();
if (ilRanges.Count > 0)
{
mre.AddAnnotation(ilRanges);
}
}
break;
}
}
}
}
}
}
private D.MethodDeclaration CreateAddAccessor(ILTranslator translator, VisitingEventArgs <EventDeclaration> e, D.ArrayType arrayType, EventDefinition ed)
{
var n = e.Node.Variables.Single().Name;
var fn = FIELD_PREFIX + n;
var union = arrayType.UnionWith(arrayType.ElementType);
var ad = new D.MethodDeclaration()
{
MethodName = ADD_PREFIX + n,
Parameters = new Collection <D.Parameter>()
{
new D.Parameter()
{
ParameterName = "value",
ParameterType = union
}
}
};
var mre = new MemberReferenceExpression()
{
Target = new ThisReferenceExpression(),
MemberName = fn
};
var ve = new IdentifierExpression("value");
mre.AddAnnotation(new TypeInformation(ed.EventType, ed.EventType));
ad.Statements = translator.GetStatements(new ExpressionStatement()
{
Expression = new AssignmentExpression()
{
Operator = AssignmentOperatorType.Add,
Left = mre,
Right = ve
}
}, e.Context);
return(ad);
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
// Console.WriteLine(objectCreateExpression.ToString());
if (objectCreateExpression.Arguments.Count == 2)
{
Expression obj = objectCreateExpression.Arguments.First();
Expression func = objectCreateExpression.Arguments.Last();
Annotation annotation = func.Annotation <Annotation>();
if (annotation != null)
{
IdentifierExpression methodIdent = (IdentifierExpression)((InvocationExpression)func).Arguments.Single();
MethodReference method = methodIdent.Annotation <MethodReference>();
if (method != null)
{
if (HandleAnonymousMethod(objectCreateExpression, obj, method))
{
// Console.WriteLine("is HandleAnonymousMethod");
return(null);
}
// Perform the transformation to "new Action(obj.func)".
obj.Remove();
methodIdent.Remove();
if (!annotation.IsVirtual && obj is ThisReferenceExpression)
{
// maybe it's getting the pointer of a base method?
if (method.DeclaringType.GetElementType() != context.CurrentType)
{
obj = new BaseReferenceExpression();
}
}
if (!annotation.IsVirtual && obj is NullReferenceExpression && !method.HasThis)
{
// We're loading a static method.
// However it is possible to load extension methods with an instance, so we compare the number of arguments:
bool isExtensionMethod = false;
TypeReference delegateType = objectCreateExpression.Type.Annotation <TypeReference>();
if (delegateType != null)
{
TypeDefinition delegateTypeDef = delegateType.Resolve();
if (delegateTypeDef != null)
{
MethodDefinition invokeMethod = delegateTypeDef.Methods.FirstOrDefault(m => m.Name == "Invoke");
if (invokeMethod != null)
{
isExtensionMethod = (invokeMethod.Parameters.Count + 1 == method.Parameters.Count);
}
}
}
if (!isExtensionMethod)
{
obj = new TypeReferenceExpression {
Type = AstBuilder.ConvertType(method.DeclaringType)
};
}
}
// now transform the identifier into a member reference
MemberReferenceExpression mre = new MemberReferenceExpression();
mre.Target = obj;
mre.MemberName = methodIdent.Identifier;
methodIdent.TypeArguments.MoveTo(mre.TypeArguments);
mre.AddAnnotation(method);
objectCreateExpression.Arguments.Clear();
objectCreateExpression.Arguments.Add(mre);
return(null);
}
}
}
return(base.VisitObjectCreateExpression(objectCreateExpression, data));
}
public override object VisitObjectCreateExpression(ObjectCreateExpression objectCreateExpression, object data)
{
if (objectCreateExpression.Arguments.Count() == 2) {
Expression obj = objectCreateExpression.Arguments.First();
Expression func = objectCreateExpression.Arguments.Last();
Annotation annotation = func.Annotation<Annotation>();
if (annotation != null) {
IdentifierExpression methodIdent = (IdentifierExpression)((InvocationExpression)func).Arguments.Single();
MethodReference method = methodIdent.Annotation<MethodReference>();
if (method != null) {
if (HandleAnonymousMethod(objectCreateExpression, obj, method))
return null;
// Perform the transformation to "new Action(obj.func)".
obj.Remove();
methodIdent.Remove();
if (!annotation.IsVirtual && obj is ThisReferenceExpression) {
// maybe it's getting the pointer of a base method?
if (method.DeclaringType != context.CurrentType) {
obj = new BaseReferenceExpression();
}
}
if (!annotation.IsVirtual && obj is NullReferenceExpression && !method.HasThis) {
// We're loading a static method.
// However it is possible to load extension methods with an instance, so we compare the number of arguments:
bool isExtensionMethod = false;
TypeReference delegateType = objectCreateExpression.Type.Annotation<TypeReference>();
if (delegateType != null) {
TypeDefinition delegateTypeDef = delegateType.Resolve();
if (delegateTypeDef != null) {
MethodDefinition invokeMethod = delegateTypeDef.Methods.FirstOrDefault(m => m.Name == "Invoke");
if (invokeMethod != null) {
isExtensionMethod = (invokeMethod.Parameters.Count + 1 == method.Parameters.Count);
}
}
}
if (!isExtensionMethod) {
obj = new TypeReferenceExpression { Type = AstBuilder.ConvertType(method.DeclaringType) };
}
}
// now transform the identifier into a member reference
MemberReferenceExpression mre = new MemberReferenceExpression();
mre.Target = obj;
mre.MemberName = methodIdent.Identifier;
methodIdent.TypeArguments.MoveTo(mre.TypeArguments);
mre.AddAnnotation(method);
objectCreateExpression.Arguments.Clear();
objectCreateExpression.Arguments.Add(mre);
return null;
}
}
}
return base.VisitObjectCreateExpression(objectCreateExpression, data);
}