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);
}
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 VisitBlockExpression(BlockExpression node)
{
WriteToken("{ ");
VisitList(node.Expressions);
WriteToken(" }");
}
private void RecordVariableAssignment(ExpressionStatement node)
{
BinaryExpression assignment = node.Expression as BinaryExpression;
VariableReference variable = (assignment.Left as VariableReferenceExpression).Variable;
assignment.Right = (Expression)Visit(assignment.Right);
Expression rightClone = assignment.Right.CloneExpressionOnly();
this.variableToValueMap[variable] = rightClone;
HashSet<ExpressionStatement> statements;
if (!this.variableToAssigingStatementsMap.TryGetValue(variable, out statements))
{
statements = new HashSet<ExpressionStatement>();
this.variableToAssigingStatementsMap[variable] = statements;
}
statements.Add(node);
ArrayCreationExpression arrayCreation = rightClone as ArrayCreationExpression;
if (arrayCreation == null || arrayCreation.Dimensions == null || arrayCreation.Dimensions.Count != 1 || arrayCreation.Initializer != null && arrayCreation.Initializer.Expressions != null &&
arrayCreation.Initializer.Expressions.Count > 0)
{
return;
}
var blockExpression = new BlockExpression(null);
arrayCreation.Initializer = new InitializerExpression(blockExpression, InitializerType.ArrayInitializer);
this.variableToLastUninitializedIndex[variable] = 0;
}
// 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 void RebuildDimensions(ref ExpressionCollection elements, ExpressionCollection dimensions)
{
int count = elements.Count;
for (int i = dimensions.Count - 1; i > 0; i--)
{
ExpressionCollection currentCollection = new ExpressionCollection();
int currentDimension = (int)(dimensions[i] as LiteralExpression).Value;
for (int j = 0; j < count; j += currentDimension)
{
BlockExpression currentBlock = new BlockExpression(null);
currentBlock.Expressions = new ExpressionCollection();
for (int k = 0; k < currentDimension; k++)
{
currentBlock.Expressions.Add(elements[j + k]);
}
currentCollection.Add(currentBlock);
}
elements = currentCollection;
count /= currentDimension;
}
}
public virtual void VisitBlockExpression(BlockExpression node)
{
Visit(node.Expressions);
}
public override Expression CloneExpressionOnly()
{
BlockExpression result = new BlockExpression(Expressions.CloneExpressionsOnly(), null);
return result;
}
public override Expression Clone()
{
BlockExpression result = new BlockExpression(Expressions.Clone(), this.instructions);
return result;
}
public InitializerExpression(BlockExpression expression, InitializerType initializerType, IEnumerable<Instruction> instructions)
: base(instructions)
{
this.Expression = expression;
this.InitializerType = initializerType;
}
public InitializerExpression(BlockExpression expression, InitializerType initializerType)
: this(expression, initializerType, Enumerable.Empty<Instruction>())
{
}
private void AddArrayInitializerCasts(TypeDefinition arrayType, BlockExpression blockExpression)
{
for (int i = 0; i < blockExpression.Expressions.Count; i++)
{
Expression element = blockExpression.Expressions[i];
// Multidimensional array
if (element.CodeNodeType == CodeNodeType.BlockExpression)
{
AddArrayInitializerCasts(arrayType, element as BlockExpression);
}
// Array elements
else if (ShouldAddCast(arrayType, element.ExpressionType))
{
blockExpression.Expressions[i] = new CastExpression(element, arrayType, null);
}
}
}