public ArrayCreationExpression(TypeReference type, InitializerExpression initializer, IEnumerable <Instruction> instructions)
: base(instructions)
{
this.ElementType = type;
this.Initializer = initializer;
this.Dimensions = new ExpressionCollection();
}
public ArrayCreationExpression(TypeReference type, InitializerExpression initializer, IEnumerable<Instruction> instructions)
:base(instructions)
{
this.ElementType = type;
this.Initializer = initializer;
this.Dimensions = new ExpressionCollection();
}
public AnonymousObjectCreationExpression(MethodReference constructor, TypeReference type, InitializerExpression initializer, IEnumerable<Instruction> instructions)
:base(instructions)
{
this.Constructor = constructor;
this.Type = type;
this.Initializer = initializer;
}
public override Expression CloneExpressionOnly()
{
InitializerExpression result = new InitializerExpression(
Expression.Clone() as BlockExpression, this.InitializerType, null);
result.IsMultiLine = this.IsMultiLine;
return result;
}
public override Expression Clone()
{
InitializerExpression result = new InitializerExpression(
Expression.Clone() as BlockExpression, this.InitializerType, this.instructions);
result.IsMultiLine = this.IsMultiLine;
return result;
}
public ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
if(node.Type == null || node.Constructor == null || !node.Type.IsGenericInstance)
{
return null;
}
TypeDefinition typeDef = node.Type.Resolve();
if (!typeDef.IsAnonymous())
{
return null;
}
initializerExpressions = new BlockExpression(null);
ProcessAnonymousType(typeDef, node.Type as GenericInstanceType, node.Constructor.Resolve(), node.Arguments);
node.Initializer = new InitializerExpression(initializerExpressions, InitializerType.ObjectInitializer);
List<Instruction> instructions = new List<Instruction>(node.MappedInstructions);
foreach (Expression argument in node.Arguments)
{
instructions.AddRange(argument.UnderlyingSameMethodInstructions);
}
InitializerExpression initializer = new InitializerExpression(initializerExpressions, InitializerType.AnonymousInitializer);
return new AnonymousObjectCreationExpression(node.Constructor, typeDef, initializer, instructions);
}
public override Expression CloneExpressionOnly()
{
InitializerExpression initializerClone = Initializer != null?Initializer.CloneExpressionOnly() as InitializerExpression : null;
AnonymousObjectCreationExpression result = new AnonymousObjectCreationExpression(Constructor, Type, initializerClone, null);
return(result);
}
public override Expression CloneExpressionOnly()
{
InitializerExpression result = new InitializerExpression(
Expression.Clone() as BlockExpression, this.InitializerType, null);
result.IsMultiLine = this.IsMultiLine;
return(result);
}
public ArrayCreationExpression(TypeReference type, InitializerExpression initializer, IEnumerable <Instruction> instructions)
{
base(instructions);
this.set_ElementType(type);
this.set_Initializer(initializer);
this.set_Dimensions(new ExpressionCollection());
return;
}
public ObjectCreationExpression(MethodReference constructor, TypeReference type, InitializerExpression initializer, IEnumerable<Instruction> instructions)
:base(instructions)
{
this.Constructor = constructor;
this.Type = type;
this.Initializer = initializer;
this.Arguments = new ExpressionCollection();
}
public override bool Equals(Expression other)
{
InitializerExpression initializer = other as InitializerExpression;
bool result = initializer != null && this.Expression.Equals(initializer.Expression) &&
this.InitializerType == initializer.InitializerType;
//this.IsMultiLine == initializer.IsMultiLine;
return(result);
}
public override Expression Clone()
{
InitializerExpression initializerClone = Initializer != null ? (InitializerExpression)Initializer.Clone() : null;
return(new ArrayCreationExpression(ElementType, initializerClone, instructions)
{
Dimensions = Dimensions.Clone()
});
}
public override Expression Clone()
{
InitializerExpression initializerClone = Initializer != null?Initializer.Clone() as InitializerExpression : null;
ObjectCreationExpression result = new ObjectCreationExpression(Constructor, Type, initializerClone, this.instructions);
result.Arguments = this.Arguments.Clone();
return(result);
}
private Expression GetMethodHandleExpression(MethodReference methodReference, IEnumerable<Instruction> instructions)
{
TypeDefinition corlibTypeTypeDefinition = GetSystemTypeTypeDefinition();
string[] parametersNames = methodReference.HasParameters ? new string[] { "System.String", "System.Type[]" } : new string[] { "System.String" };
MethodReference getMethodReference = GetSystemTypeMethodReference(corlibTypeTypeDefinition, "GetMethod", parametersNames);
MethodReference getMethodHandleReference = GetHandlePropertyGetterReference(typeof(System.Reflection.MethodBase), "get_MethodHandle");
TypeOfExpression typeOfExpression = new TypeOfExpression(methodReference.DeclaringType, null);
MethodReferenceExpression getMethodMethodReferenceExpression = new MethodReferenceExpression(typeOfExpression, getMethodReference, null);
MethodInvocationExpression getMethodMethodInvocationExpression = new MethodInvocationExpression(getMethodMethodReferenceExpression, null);
LiteralExpression argument = new LiteralExpression(methodReference.Name, this.typeSystem, null);
getMethodMethodInvocationExpression.Arguments.Add(argument);
if (methodReference.HasParameters)
{
BlockExpression blockExpression = new BlockExpression(null);
foreach (ParameterDefinition parameter in methodReference.Parameters)
{
blockExpression.Expressions.Add(new TypeOfExpression(parameter.ParameterType, null));
}
InitializerExpression initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer);
ArrayCreationExpression getMethodTypeParametersArray = new ArrayCreationExpression(corlibTypeTypeDefinition, initializer, null);
getMethodTypeParametersArray.Dimensions.Add(new LiteralExpression(blockExpression.Expressions.Count, this.typeSystem, null));
getMethodMethodInvocationExpression.Arguments.Add(getMethodTypeParametersArray);
}
MethodReferenceExpression getMethodHandleMethodReferenceExpression = new MethodReferenceExpression(getMethodMethodInvocationExpression, getMethodHandleReference, null);
MethodInvocationExpression getMethodHandleMethodInvocationExpression = new MethodInvocationExpression(getMethodHandleMethodReferenceExpression, instructions);
PropertyReferenceExpression methodHandlePropertyReferenceExpression = new PropertyReferenceExpression(getMethodHandleMethodInvocationExpression, null);
return methodHandlePropertyReferenceExpression;
}
public override void VisitInitializerExpression(InitializerExpression node)
{
count--;
Visit(node.Expression);
}
public override void VisitInitializerExpression(InitializerExpression node)
{
WriteToken("{");
if (node.IsMultiLine)
{
Indent();
WriteLine();
VisitMultilineList(node.Expressions);
WriteLine();
Outdent();
}
else
{
WriteSpace();
VisitList(node.Expressions);
WriteSpace();
}
WriteToken("}");
}
protected void StartInitializer(InitializerExpression node)
{
if (node.IsMultiLine)
{
WriteLine();
}
else
{
WriteSpace();
}
}
public AnonymousObjectCreationExpression(MethodReference constructor, TypeReference type, InitializerExpression initializer, IEnumerable <Instruction> instructions)
{
base(instructions);
this.set_Constructor(constructor);
this.set_Type(type);
this.set_Initializer(initializer);
return;
}
public virtual void VisitInitializerExpression(InitializerExpression node)
{
Visit(node.Expression);
}
// Person person = new Person { Name = "John", Age = 20 };
//
// ==
//
// Person person = new Person();
// person.Name = "John";
// person.Age = 20;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return false;
}
ExpressionCollection inlinedExpressions = new ExpressionCollection();
HashSet<string> visitedPropertyNames = new HashSet<string>();
if (objectCreation.Initializer != null)
{
if (objectCreation.Initializer.InitializerType != InitializerType.ObjectInitializer)
{
return false;
}
foreach (var item in objectCreation.Initializer.Expressions)
{
string name = GetName((item as BinaryExpression).Left);
visitedPropertyNames.Add(name);
}
}
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
BinaryExpression assignment = expression as BinaryExpression;
if (!IsObjectPropertyOrFieldAssignment(assignment, assignee))
{
break;
}
Expression initializer = null;
if (assignment.Left.CodeNodeType == CodeNodeType.PropertyReferenceExpression)
{
PropertyDefinition property = (assignment.Left as PropertyReferenceExpression).Property;
if (!Visit(property.Name, visitedPropertyNames))
{
break;
}
initializer = new PropertyInitializerExpression(property, property.PropertyType,
assignment.Right.UnderlyingSameMethodInstructions);
}
else if (assignment.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldDefinition field = (assignment.Left as FieldReferenceExpression).Field.Resolve();
if (!Visit(field.Name, visitedPropertyNames))
{
break;
}
initializer = new FieldInitializerExpression(field, field.FieldType,
assignment.Right.UnderlyingSameMethodInstructions);
}
var inlinedAssignment = new BinaryExpression(BinaryOperator.Assign,
initializer, assignment.Right.Clone(), this.typeSystem, null);
inlinedExpressions.Add(inlinedAssignment);
}
if (inlinedExpressions.Count == 0)
{
return false;
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(inlinedExpressions, InitializerType.ObjectInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in inlinedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = inlinedExpressions.Count + 1;
return true;
}
public ObjectCreationExpression(MethodReference constructor, TypeReference type, InitializerExpression initializer, IEnumerable <Instruction> instructions)
: base(instructions)
{
this.Constructor = constructor;
this.Type = type;
this.Initializer = initializer;
this.Arguments = new ExpressionCollection();
}
// MyCollection list = new MyCollection() { 1, { 2, 2 } , 3 };
//
// ==
//
// MyCollection temp = new MyCollection();
// temp.Add(1);
// temp.Add(2, 2);
// temp.Add(3);
// MyCollection list = temp;
protected override bool TryMatchInternal(StatementCollection statements, int startIndex, out Statement result, out int replacedStatementsCount)
{
result = null;
replacedStatementsCount = 0;
ObjectCreationExpression objectCreation;
Expression assignee;
if (!TryGetObjectCreation(statements, startIndex, out objectCreation, out assignee))
{
return false;
}
if (objectCreation.Initializer != null && objectCreation.Initializer.InitializerType != InitializerType.CollectionInitializer)
{
return false;
}
if (!ImplementsInterface(objectCreation.Type, "System.Collections.IEnumerable"))
{
return false;
}
ExpressionCollection addedExpressions = new ExpressionCollection();
for (int i = startIndex + 1; i < statements.Count; i++)
{
Expression expression;
if (!TryGetNextExpression(statements[i], out expression))
{
break;
}
if (expression.CodeNodeType != CodeNodeType.MethodInvocationExpression)
{
break;
}
MethodInvocationExpression methodInvocation = (expression as MethodInvocationExpression);
MethodDefinition methodDefinition = methodInvocation.MethodExpression.MethodDefinition;
if (!CompareTargets(assignee, methodInvocation.MethodExpression.Target))
{
break;
}
if (methodDefinition.Name != "Add")
{
break;
}
if (methodInvocation.Arguments.Count == 0)
{
break;
}
else if (methodInvocation.Arguments.Count == 1)
{
addedExpressions.Add(methodInvocation.Arguments[0].Clone());
}
else
{
ExpressionCollection currentArguments = new ExpressionCollection(
methodInvocation.Arguments.Select(x => x.Clone()));
BlockExpression blockExpression = new BlockExpression(currentArguments, null);
addedExpressions.Add(blockExpression);
}
}
if (addedExpressions.Count == 0)
{
return false;
}
if (objectCreation.Initializer == null)
{
var initializer = new InitializerExpression(addedExpressions, InitializerType.CollectionInitializer);
initializer.IsMultiLine = true;
objectCreation.Initializer = initializer;
}
else
{
foreach (var item in addedExpressions)
{
objectCreation.Initializer.Expressions.Add(item);
}
}
result = statements[startIndex];
replacedStatementsCount = addedExpressions.Count + 1;
return true;
}
public AnonymousObjectCreationExpression(MethodReference constructor, TypeReference type, InitializerExpression initializer, IEnumerable <Instruction> instructions)
: base(instructions)
{
this.Constructor = constructor;
this.Type = type;
this.Initializer = initializer;
}
public override Telerik.JustDecompiler.Ast.Expressions.Expression Clone()
{
stackVariable8 = new InitializerExpression(this.get_Expression().Clone() as BlockExpression, this.get_InitializerType(), this.instructions);
stackVariable8.set_IsMultiLine(this.get_IsMultiLine());
return(stackVariable8);
}
public override Telerik.JustDecompiler.Ast.Expressions.Expression CloneExpressionOnly()
{
stackVariable7 = new InitializerExpression(this.get_Expression().Clone() as BlockExpression, this.get_InitializerType(), null);
stackVariable7.set_IsMultiLine(this.get_IsMultiLine());
return(stackVariable7);
}
