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 ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
FixArguments(node.Constructor, node.Arguments);
return node;
}
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);
}
public override Expression Clone()
{
if (this.get_Initializer() != null)
{
stackVariable5 = this.get_Initializer().Clone() as InitializerExpression;
}
else
{
stackVariable5 = null;
}
V_0 = stackVariable5;
stackVariable13 = new ObjectCreationExpression(this.get_Constructor(), this.get_Type(), V_0, this.instructions);
stackVariable13.set_Arguments(this.get_Arguments().Clone());
return(stackVariable13);
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
ICodeNode result = rebuildAnonymousInitializersStep.VisitObjectCreationExpression(node);
if (result != null)
{
return result;
}
return base.VisitObjectCreationExpression(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
MethodReference calledMethod = node.Constructor;
if (calledMethod != null)
{
FixArguments(calledMethod, node.Arguments);
}
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
CastMethodArguments(node.Constructor, node.Arguments);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (state == SearchState.Propagation)
{
canBePropagated = false;
return;
}
base.VisitObjectCreationExpression(node);
}
private bool IsNewDelegate(ObjectCreationExpression node)
{
if (node.Constructor == null || node.Constructor.DeclaringType == null)
{
return false;
}
TypeDefinition typeDef = node.Constructor.DeclaringType.Resolve();
if (typeDef != null && typeDef.BaseType != null && typeDef.BaseType.FullName == typeof(MulticastDelegate).FullName)
{
return true;
}
return false;
}
protected virtual void WriteDelegateCreation(ObjectCreationExpression node)
{
WriteKeyword(KeyWordWriter.New);
WriteSpace();
WriteReferenceAndNamespaceIfInCollision(node.ExpressionType);
WriteToken("(");
WriteDelegateArgument(node);
WriteToken(")");
}
private void WriteConstructorInvocation(ObjectCreationExpression node)
{
if (node.Constructor.DeclaringType is TypeSpecification)
{
GenericInstanceType generic = node.Constructor.DeclaringType as GenericInstanceType;
if (generic != null)
{
if (SupportsSpecialNullable && (generic.GetFriendlyFullName(Language).IndexOf("System.Nullable<") == 0) &&
generic.GenericArguments[0].IsValueType)
{
TypeReference toWrite = generic.GenericArguments[0];
if (generic.PostionToArgument.ContainsKey(0))
{
toWrite = generic.PostionToArgument[0];
}
WriteReferenceAndNamespaceIfInCollision(toWrite);
WriteToken("?");
return;
}
}
}
if (node.Constructor.DeclaringType.Namespace == "System")
{
WriteReferenceAndNamespaceIfInCollision(node.Constructor.DeclaringType);
return;
}
if (node.Constructor.DeclaringType.DeclaringType != null)
{
TypeReference declaringType = node.Constructor.DeclaringType.DeclaringType;
if (node.Constructor.DeclaringType.IsGenericInstance)
{
GenericInstanceType referenceGeneric = node.Constructor.DeclaringType as GenericInstanceType;
if (declaringType.HasGenericParameters)
{
/// Transfer the parameters from reference up to the declaring type.
/// Bare in mind, that the declaring type might have less generic parameters.
/// Transfer just the first X that match.
/// This is needed, because VB and C# don't allow other language syntax
GenericInstanceType declaringTypeInstance = new GenericInstanceType(declaringType);
Collection<TypeReference> nestedTypeBackup = new Collection<TypeReference>(referenceGeneric.GenericArguments);
Collection<TypeReference> declaringBackup = new Collection<TypeReference>(declaringTypeInstance.GenericArguments);
int parametersToMoveUp = declaringType.GenericParameters.Count;
for (int i = 0; i < parametersToMoveUp; i++)
{
/// check if it moves the parameters forward or not
declaringTypeInstance.AddGenericArgument(referenceGeneric.GenericArguments[i]);
declaringTypeInstance.GenericArguments.Add(referenceGeneric.GenericArguments[i]);
}
WriteReferenceAndNamespaceIfInCollision(declaringTypeInstance);
Write(".");
if (referenceGeneric.GenericArguments.Count - parametersToMoveUp > 0)
{
WriteConstructorNameAndGenericArguments(node, true, parametersToMoveUp);
}
else
{
WriteConstructorNameAndGenericArguments(node, false);
}
referenceGeneric.GenericArguments.Clear();
referenceGeneric.GenericArguments.AddRange(nestedTypeBackup);
declaringTypeInstance.GenericArguments.Clear();
declaringTypeInstance.GenericArguments.AddRange(declaringBackup);
return;
}
}
WriteReferenceAndNamespaceIfInCollision(declaringType);
Write(".");
WriteConstructorNameAndGenericArguments(node);
}
else
{
bool isTypeNameInCollision = IsTypeNameInCollision(node.Constructor.DeclaringType.Name);
WriteNamespace(node.Constructor.DeclaringType.GetElementType(), isTypeNameInCollision);
WriteConstructorNameAndGenericArguments(node);
}
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
node = (ObjectCreationExpression)base.VisitObjectCreationExpression(node);
if (node.Arguments.Count != 0)
{
VisitInvocationArguments(node.Arguments, node.Constructor);
}
return node;
}
/// <summary>
/// Determines the use type of <paramref name="variable"/> in <paramref name="objectCreationExpression"/>.
/// </summary>
/// <param name="objectCreationExpression">The object creataion expression.</param>
/// <param name="variable">The variable.</param>
/// <returns>Returns the ClassHierarchyNode corresponding to the infered type.</returns>
private ClassHierarchyNode GetUseInObjectCreation(ObjectCreationExpression objectCreationExpression, VariableReference variable)
{
Expression arg = null;
foreach (Expression expr in objectCreationExpression.Arguments)
{
if (expr is VariableReferenceExpression && (expr as VariableReferenceExpression).Variable == variable)
{
arg = expr;
}
}
return GetTypeNode(objectCreationExpression.Constructor.Parameters[objectCreationExpression.Arguments.IndexOf(arg)].ParameterType);
}
protected bool TryGetObjectCreation(StatementCollection statements, int startIndex, out ObjectCreationExpression creation, out Expression assignee)
{
assignee = null;
creation = null;
BinaryExpression binaryExpression;
if (!TryGetAssignment(statements, startIndex, out binaryExpression))
{
return false;
}
if (binaryExpression.Right.CodeNodeType != CodeNodeType.ObjectCreationExpression)
{
return false;
}
assignee = binaryExpression.Left;
creation = binaryExpression.Right as ObjectCreationExpression;
return true;
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
MethodReference ctorMethod = node.Constructor;
if (ctorMethod != null)
{
TraverseMethodParameters(ctorMethod, node.Arguments);
}
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (state == State.ReplaceDelegate && node.Arguments != null && node.Arguments.Count == 2 &&
node.Arguments[0].CodeNodeType == CodeNodeType.VariableReferenceExpression &&
node.Arguments[1].CodeNodeType == CodeNodeType.MethodReferenceExpression &&
delegateCopies.Contains((node.Arguments[0] as VariableReferenceExpression).Variable))
{
//final check inserted here for optimization
TypeDefinition objectType = node.Constructor.DeclaringType.Resolve();
if (objectType == null || objectType.BaseType == null || objectType.BaseType.FullName != "System.MulticastDelegate")
{
return base.VisitObjectCreationExpression(node);
}
MethodReference methodReference = (node.Arguments[1] as MethodReferenceExpression).Method;
MethodDefinition methodDefinition = (node.Arguments[1] as MethodReferenceExpression).MethodDefinition;
MethodSpecificContext delegateMethodContext = new MethodSpecificContext(methodDefinition.Body);
DecompilationContext innerContext = new DecompilationContext(delegateMethodContext, context.TypeContext, context.ModuleContext, context.AssemblyContext);
delegateMethodContext.FieldToExpression = fieldDefToAssignedValueMap;
BlockStatement methodStatements = methodDefinition.Body.DecompileLambda(Language, innerContext);
if ((methodStatements.Statements.Count == 1) && (methodStatements.Statements[0].CodeNodeType == CodeNodeType.ExpressionStatement) &&
((methodStatements.Statements[0] as ExpressionStatement).Expression.CodeNodeType == CodeNodeType.ReturnExpression))
{
ReturnExpression returnExpression = (methodStatements.Statements[0] as ExpressionStatement).Expression as ReturnExpression;
ShortFormReturnExpression shortFormReturnExpression = new ShortFormReturnExpression(returnExpression.Value, returnExpression.MappedInstructions);
methodStatements = new BlockStatement();
methodStatements.Statements.Add(new ExpressionStatement(shortFormReturnExpression));
}
this.context.MethodContext.VariableDefinitionToNameMap.AddRange(innerContext.MethodContext.VariableDefinitionToNameMap);
this.context.MethodContext.VariableNamesCollection.UnionWith(innerContext.MethodContext.VariableNamesCollection);
this.context.MethodContext.AddInnerMethodParametersToContext(innerContext.MethodContext);
this.context.MethodContext.GotoStatements.AddRange(innerContext.MethodContext.GotoStatements);
this.context.MethodContext.GotoLabels.AddRange(innerContext.MethodContext.GotoLabels);
ExpressionCollection expressionCollection = new ExpressionCollection();
bool hasAnonymousParamterer = LambdaExpressionsHelper.HasAnonymousParameter(methodDefinition.Parameters);
foreach (ParameterDefinition parameter in methodDefinition.Parameters)
{
expressionCollection.Add(new LambdaParameterExpression(parameter, !hasAnonymousParamterer, null));
}
delegatesFound.Add(methodStatements);
LambdaExpression lambdaExpression =
new LambdaExpression(expressionCollection, methodStatements, methodDefinition.IsAsync(), methodDefinition.IsFunction(), methodReference.Parameters, false,
node.Arguments[1].MappedInstructions) { ExpressionType = objectType };
DelegateCreationExpression result = new DelegateCreationExpression(node.Constructor.DeclaringType, lambdaExpression, node.Arguments[0], node.MappedInstructions);
return result;
}
return base.VisitObjectCreationExpression(node);
}
public virtual void VisitObjectCreationExpression(ObjectCreationExpression node)
{
Visit(node.Arguments);
Visit(node.Initializer);
}
public override Expression CloneExpressionOnly()
{
InitializerExpression initializerClone = Initializer != null ? Initializer.CloneExpressionOnly() as InitializerExpression : null;
ObjectCreationExpression result = new ObjectCreationExpression(Constructor, Type, initializerClone, null)
{ Arguments = this.Arguments.CloneExpressionsOnly() };
return result;
}
public override bool Equals(Expression other)
{
if (!(other is ObjectCreationExpression))
{
return(false);
}
ObjectCreationExpression objectCreation = other as ObjectCreationExpression;
#region CheckConstructor
if (this.Constructor == null)
{
if (objectCreation.Constructor != null)
{
return(false);
}
}
else
{
if (objectCreation.Constructor == null || this.Constructor.FullName != objectCreation.Constructor.FullName)
{
return(false);
}
}
#endregion
#region CheckArguments
if (this.Arguments == null)
{
if (objectCreation.Arguments != null)
{
return(false);
}
}
else if (objectCreation.Arguments == null || !this.Arguments.Equals(objectCreation.Arguments))
{
return(false);
}
#endregion
#region CheckType
if (this.Type == null)
{
if (objectCreation.Type != null)
{
return(false);
}
}
else if (objectCreation.Type == null || this.Type.FullName != objectCreation.Type.FullName)
{
return(false);
}
#endregion
#region CheckInitializer
if (this.Initializer == null)
{
if (objectCreation.Initializer != null)
{
return(false);
}
}
else if (objectCreation.Initializer == null || !this.Initializer.Equals(objectCreation.Initializer))
{
return(false);
}
#endregion
return(true);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.Constructor != null)
{
TrySetObjectCreationPendingName(node.Constructor.DeclaringType);
}
ClearPendingForSuggestion();
base.VisitObjectCreationExpression(node);
}
private void WriteConstructorNameAndGenericArguments(ObjectCreationExpression node, bool writeGenericArguments = true, int startArgumentIndex = 0)
{
string constructorName = GetTypeName(node.Constructor.DeclaringType);
WriteReference(constructorName, node.Constructor);
if (writeGenericArguments)
{
if (node.ExpressionType.IsGenericInstance)
{
WriteToken(GenericLeftBracket);
Mono.Collections.Generic.Collection<TypeReference> arguments = (node.ExpressionType as GenericInstanceType).GenericArguments;
for (int i = startArgumentIndex; i < arguments.Count; i++)
{
if (i > startArgumentIndex)
{
WriteToken(",");
WriteSpace();
}
WriteReferenceAndNamespaceIfInCollision(arguments[i]);
}
WriteToken(GenericRightBracket);
}
}
}
protected override void WriteDelegateCreation(ObjectCreationExpression node)
{
WriteKeyword(KeyWordWriter.New);
WriteSpace();
WriteReferenceAndNamespaceIfInCollision(node.ExpressionType);
WriteToken("(");
WriteKeyword(KeyWordWriter.AddressOf);
WriteSpace();
Write(node.Arguments[1]);
WriteToken(")");
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (IsNewDelegate(node))
{
WriteDelegateCreation(node);
return;
}
WriteKeyword(KeyWordWriter.New);
WriteSpace();
if (node.Constructor != null)
{
WriteConstructorInvocation(node);
}
else
{
WriteReferenceAndNamespaceIfInCollision(node.Type);
}
WriteToken("(");
EnterMethodInvocation(node.Constructor);
VisitMethodParameters(node.Arguments);
LeaveMethodInvocation();
WriteToken(")");
if (node.Initializer != null)
{
if (node.Initializer.InitializerType == InitializerType.ObjectInitializer)
{
if (KeyWordWriter.ObjectInitializer != null)
{
WriteSpace();
WriteKeyword(KeyWordWriter.ObjectInitializer);
}
}
else if (node.Initializer.InitializerType == InitializerType.CollectionInitializer)
{
if (KeyWordWriter.CollectionInitializer != null)
{
WriteSpace();
WriteKeyword(KeyWordWriter.CollectionInitializer);
}
}
StartInitializer(node.Initializer);
Visit(node.Initializer);
}
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
if (node.Constructor == null)
{
return node;
}
TypeDefinition objectType = node.Constructor.DeclaringType.Resolve();
if (objectType == null || objectType.BaseType == null || objectType.BaseType.FullName != "System.MulticastDelegate" ||
node.Arguments.Count != 2 || node.Arguments[1].CodeNodeType != CodeNodeType.LambdaExpression)
{
return node;
}
(node.Arguments[1] as LambdaExpression).ExpressionType = objectType;
Expression target = node.Arguments[0];
return new DelegateCreationExpression(node.ExpressionType, node.Arguments[1], target, node.MappedInstructions);
}
protected void WriteDelegateArgument(ObjectCreationExpression node)
{
//if (node.Arguments[1].CodeNodeType == CodeNodeType.LambdaExpression)
//{
// VisitLambdaExpression((LambdaExpression)node.Arguments[1]);
// return;
//}
if ((node.Arguments[0].CodeNodeType != CodeNodeType.LiteralExpression ||
(node.Arguments[0] as LiteralExpression).Value != null) &&
(node.Arguments[1] as MethodReferenceExpression) != null &&
(node.Arguments[1] as MethodReferenceExpression).Target == null)
{
Write(node.Arguments[0]);
WriteToken(".");
WriteMethodReference(node.Arguments[1] as MethodReferenceExpression);
}
else
{
Write(node.Arguments[1]);
}
}
private ICodeNode ConvertNewObject(MethodInvocationExpression invocation)
{
if (invocation.Arguments.Count < 1 || invocation.Arguments.Count > 3)
{
return null;
}
Expression visitedFirst = (Expression)Visit(invocation.Arguments[0]);
MethodReference constructorReference;
if (!TryGetMethodReference(visitedFirst, "System.Reflection.ConstructorInfo", out constructorReference))
{
if (invocation.Arguments.Count != 1 || visitedFirst.CodeNodeType != CodeNodeType.TypeOfExpression)
{
return null;
}
return new ObjectCreationExpression(null, (visitedFirst as TypeOfExpression).Type, null, null);
}
ObjectCreationExpression creationExpression = new ObjectCreationExpression(constructorReference, constructorReference.DeclaringType, null, null);
if (invocation.Arguments.Count == 1)
{
return creationExpression;
}
ArrayCreationExpression argumentsArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (argumentsArray == null || argumentsArray.Dimensions.Count != 1 || argumentsArray.Initializer == null ||
argumentsArray.Initializer.Expressions == null || argumentsArray.Initializer.Expressions.Count != constructorReference.Parameters.Count)
{
return null;
}
foreach (Expression argument in argumentsArray.Initializer.Expressions)
{
creationExpression.Arguments.Add(argument);
}
if (invocation.Arguments.Count == 2)
{
return creationExpression;
}
Visit(invocation.Arguments[2]);
return creationExpression;
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
TypesDependingOn.UnionWith(Utilities.GetTypeReferenceTypesDepedningOn(node.ExpressionType));
base.VisitObjectCreationExpression(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
if (node.Constructor != null)
{
CheckArguments(node.Constructor.Parameters, node.Arguments);
}
// node.Initializer contains BinaryExpressions
}
