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 }