private ICodeNode ConvertMemberInit(MethodInvocationExpression invocation)
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
ObjectCreationExpression creation = Visit(invocation.Arguments[0]) as ObjectCreationExpression;
if (creation == null || creation.Initializer != null)
{
return(null);
}
ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Dimensions.Count != 1 || initializerArray.Initializer == null ||
initializerArray.Initializer.Expressions == null ||
initializerArray.Initializer.Expressions.Any(expr => expr.CodeNodeType != CodeNodeType.BinaryExpression || !(expr as BinaryExpression).IsAssignmentExpression))
{
return(null);
}
if (initializerArray.Initializer.Expressions.Count > 0)
{
creation.Initializer = new InitializerExpression(initializerArray.Initializer.Expression, InitializerType.ObjectInitializer);
creation.Initializer.IsMultiLine = true;
}
return(creation);
}
public CCodeBoxForPrimitiveValuesOrEnumsDeclaration(INamedTypeSymbol type)
: base(new BoxMethod(type))
{
this.type = type;
var specialTypeConstructorMethod = new CCodeSpecialTypeOrEnumConstructorDeclaration.SpecialTypeConstructorMethod(type);
var objectCreationExpression = new ObjectCreationExpression
{
Type = type,
IsReference = true,
Method = specialTypeConstructorMethod,
Arguments =
{
new Parameter
{
ParameterSymbol =
specialTypeConstructorMethod.Parameters.First()
}
}
};
MethodBodyOpt = new MethodBody(Method)
{
Statements = { new ReturnStatement {
ExpressionOpt = objectCreationExpression
} }
};
}
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 ICodeNode ConvertListInit(MethodInvocationExpression invocation)
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
ObjectCreationExpression creation = Visit(invocation.Arguments[0]) as ObjectCreationExpression;
if (creation == null || creation.Initializer != null)
{
return(null);
}
ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Dimensions.Count != 1 || initializerArray.Initializer == null ||
initializerArray.Initializer.Expressions == null)
{
return(null);
}
creation.Initializer = new InitializerExpression(initializerArray.Initializer.Expression, InitializerType.CollectionInitializer);
creation.Initializer.IsMultiLine = true;
return(creation);
}
public override INode VisitObjectCreationExpression(ObjectCreationExpression objectCreationExpression)
{
return(new ObjectCreationExpression(objectCreationExpression.Context, objectCreationExpression.Children.Select(Visit))
{
Type = objectCreationExpression.Type
});
}
private bool CheckDelegateCreation(BinaryExpression theAssignExpression)
{
if (theAssignExpression.Left.CodeNodeType != CodeNodeType.VariableReferenceExpression ||
theAssignExpression.Right.CodeNodeType != CodeNodeType.ObjectCreationExpression)
{
return(false);
}
ObjectCreationExpression theObjectCreation = theAssignExpression.Right as ObjectCreationExpression;
if (theObjectCreation.Arguments.Count != 0)
{
return(false);
}
TypeDefinition createdObjectType = theObjectCreation.ExpressionType.Resolve();
if (createdObjectType == null || !CheckTypeForCompilerGeneratedAttribute(createdObjectType))
{
return(false);
}
this.delegateTypeDef = createdObjectType;
delegateVariableReference = (theAssignExpression.Left as VariableReferenceExpression).Variable;
return(true);
}
private TypeReference GetUseInObjectCreation(ObjectCreationExpression objectCreationExpression, VariableReference variable)
{
V_0 = null;
V_1 = objectCreationExpression.get_Arguments().GetEnumerator();
try
{
while (V_1.MoveNext())
{
V_2 = V_1.get_Current();
if (V_2 as VariableReferenceExpression == null || (object)(V_2 as VariableReferenceExpression).get_Variable() != (object)variable)
{
continue;
}
V_0 = V_2;
}
}
finally
{
if (V_1 != null)
{
V_1.Dispose();
}
}
return(objectCreationExpression.get_Constructor().get_Parameters().get_Item(objectCreationExpression.get_Arguments().IndexOf(V_0)).ResolveParameterType(objectCreationExpression.get_Constructor()));
}
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 override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
FixArguments(node.Constructor, node.Arguments);
return(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
this.VisitObjectCreationExpression(node);
if (node.get_Constructor() != null)
{
this.CheckArguments(node.get_Constructor().get_Parameters(), node.get_Arguments());
}
return;
}
public override void ExitObjectCreationExpression(ObjectCreationExpression objectCreationExpression)
{
Errors.Add(new CompilationError(objectCreationExpression.Context, "It is not possible to create new objects."));
if (!(objectCreationExpression.CreatedType is ReferenceType referenceType) || !(referenceType.Declaration is ClassDeclaration))
{
Errors.Add(new CompilationError(objectCreationExpression.Context, $"{objectCreationExpression.CreatedType} is not a class. You can not use new."));
}
objectCreationExpression.Type = objectCreationExpression.CreatedType;
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
WriteKeyword("new");
WriteSpace();
WriteReference(node.Constructor != null ? node.Constructor.DeclaringType : node.Type);
WriteToken("(");
Visit(node.Arguments);
WriteToken(")");
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
node = (ObjectCreationExpression)this.VisitObjectCreationExpression(node);
if (node.get_Arguments().get_Count() != 0)
{
this.VisitInvocationArguments(node.get_Arguments(), node.get_Constructor());
}
return(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (state == SearchState.Propagation)
{
canBePropagated = false;
return;
}
base.VisitObjectCreationExpression(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.Constructor != null)
{
TrySetObjectCreationPendingName(node.Constructor.DeclaringType);
}
ClearPendingForSuggestion();
base.VisitObjectCreationExpression(node);
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
V_0 = this.rebuildAnonymousInitializersStep.VisitObjectCreationExpression(node);
if (V_0 != null)
{
return(V_0);
}
return(this.VisitObjectCreationExpression(node));
}
public override ICodeNode VisitObjectCreationExpression(ObjectCreationExpression node)
{
node = (ObjectCreationExpression)base.VisitObjectCreationExpression(node);
if (node.Arguments.Count != 0)
{
VisitInvocationArguments(node.Arguments, node.Constructor);
}
return(node);
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (this.state == ExpressionPropagationStep.ExpressionTreeVisitor.SearchState.Propagation)
{
this.canBePropagated = false;
return;
}
this.VisitObjectCreationExpression(node);
return;
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
if (node.get_Constructor() != null)
{
this.TrySetObjectCreationPendingName(node.get_Constructor().get_DeclaringType());
}
this.ClearPendingForSuggestion();
this.VisitObjectCreationExpression(node);
return;
}
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);
MethodReference ctorMethod = node.Constructor;
if (ctorMethod != null)
{
TraverseMethodParameters(ctorMethod, node.Arguments);
}
}
public override void OnInitobj(Instruction instruction)
{
var address = (AddressOfExpression)Pop();
var type = (TypeReference)instruction.Operand;
var @new = new ObjectCreationExpression(null, type, null);
Push(new AssignExpression(address.Expression, @new));
}
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)
{
this.VisitObjectCreationExpression(node);
V_0 = node.get_Constructor();
if (V_0 != null)
{
this.TraverseMethodParameters(V_0, node.get_Arguments());
}
return;
}
public override void VisitObjectCreationExpression(ObjectCreationExpression node)
{
base.VisitObjectCreationExpression(node);
if (node.Constructor != null)
{
CheckArguments(node.Constructor.Parameters, node.Arguments);
}
// node.Initializer contains BinaryExpressions
}
public override void OnNewobj(Instruction instruction)
{
var constructor = (MethodReference)instruction.Operand;
var arguments = PopRange(constructor.Parameters.Count);
var @new = new ObjectCreationExpression(constructor, null, null);
AddRange(@new.Arguments, arguments);
Push(@new);
}
/// <summary>
/// </summary>
/// <param name="c">
/// </param>
/// <param name="newNonStaticMethod">
/// </param>
/// <param name="nonStaticType">
/// </param>
private static void WriteNewMethod(CCodeWriterBase c, IMethodSymbol newNonStaticMethod, NamedTypeImpl nonStaticType)
{
c.WriteMethodDeclaration(newNonStaticMethod, true, true);
c.NewLine();
c.OpenBlock();
var objectCreationExpression = new ObjectCreationExpression {
Type = nonStaticType, NewOperator = true
};
foreach (var parameter in newNonStaticMethod.Parameters)
{
Expression parameterExpression = new Parameter {
ParameterSymbol = parameter
};
if (parameter.Name == "m")
{
parameterExpression = new Cast
{
Operand = parameterExpression,
MapPointerCast = true,
MapPointerCastTypeParameter1 =
new Access
{
AccessType = Access.AccessTypes.DoubleColon,
ReceiverOpt = new TypeExpression {
Type = nonStaticType, TypeNameRequred = true
},
Expression = new Parameter {
ParameterSymbol = new ParameterImpl {
Name = "_Memptr"
}
}
},
MapPointerCastTypeParameter2 = new TypeExpression {
Type = new TypeImpl {
TypeKind = TypeKind.TypeParameter, Name = "_Memptr"
}
},
};
}
objectCreationExpression.Arguments.Add(parameterExpression);
}
new ReturnStatement {
ExpressionOpt = objectCreationExpression
}.WriteTo(c);
c.EndBlockWithoutNewLine();
c.EndStatement();
}
static dynamic handle(ObjectCreationExpression v)
{
string typename = ((dynamic)v.Type).GenericIdentifier;
var obj = new ObjectInstance(typename, localVarDeclarationName);
//TODO: argument list needs to be applied to a constructor => v.ArgumentsList
if (localVarDeclarationName != null)
{
executingFunction.Localvars[localVarDeclarationName] = obj; //-> e.g. new Class() will not be a tracked local
}
localVarDeclarationName = null;
return(obj);
}
/// <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 TypeReference 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(objectCreationExpression.Constructor.Parameters[objectCreationExpression.Arguments.IndexOf(arg)].ResolveParameterType(objectCreationExpression.Constructor));
}
public static UstNode GetObject(string type)
{
UstNode ustNode = null;
switch (type)
{
case IdConstants.RootIdName:
ustNode = new RootUstNode();
break;
case IdConstants.UsingDirectiveIdName:
ustNode = new UsingDirective();
break;
case IdConstants.NamespaceIdName:
ustNode = new NamespaceDeclaration();
break;
case IdConstants.ClassIdName:
ustNode = new ClassDeclaration();
break;
case IdConstants.InterfaceIdName:
ustNode = new InterfaceDeclaration();
break;
case IdConstants.BodyIdName:
ustNode = new BlockStatement();
break;
case IdConstants.ObjectCreationIdName:
ustNode = new ObjectCreationExpression();
break;
case IdConstants.InvocationIdName:
ustNode = new InvocationExpression();
break;
case IdConstants.LiteralIdName:
ustNode = new LiteralExpression();
break;
case IdConstants.MethodIdName:
ustNode = new MethodDeclaration();
break;
default: break;
}
return(ustNode);
}
private static bool IsInsideInitializerToTypeWithSource(CheckContentAvailabilityEventArgs ea)
{
_TypeElement = null;
_ObjectCreationExpression = ea.Element as ObjectCreationExpression;
if (_ObjectCreationExpression == null)
{
_ObjectCreationExpression = ea.Element.GetParent(LanguageElementType.ObjectCreationExpression) as ObjectCreationExpression;
if (_ObjectCreationExpression == null)
return false;
}
_InitializerExpression = _ObjectCreationExpression.ObjectInitializer;
if (_InitializerExpression == null)
return false;
_TypeElement = _ObjectCreationExpression.ObjectType.Resolve(ParserServices.SourceTreeResolver) as ITypeElement;
if (_TypeElement == null)
return false;
return !_TypeElement.InReferencedAssembly;
}
public void VisitObjectCreationExpression(ObjectCreationExpression creation)
{
throw new NotImplementedException();
}
private string GetNewConstructorCall(ObjectCreationExpression objectCreationWithInitializer, ITypeElement type)
{
string result = String.Empty;
if (type == null || objectCreationWithInitializer == null || objectCreationWithInitializer.ObjectInitializer == null)
return result;
ExpressionCollection arguments = objectCreationWithInitializer.ObjectInitializer.Initializers;
ExpressionCollection newArgs = new ExpressionCollection();
foreach (Expression argument in arguments)
{
MemberInitializerExpression memberInitializerExpression = argument as MemberInitializerExpression;
if (memberInitializerExpression == null)
continue;
newArgs.Add(memberInitializerExpression.Value);
}
ObjectCreationExpression newObjectCreationExpression = new ObjectCreationExpression(new TypeReferenceExpression(type.Name), newArgs);
if (newObjectCreationExpression != null)
result = CodeRush.Language.GenerateElement(newObjectCreationExpression);
return result;
}
public void VisitObjectCreationExpression(ObjectCreationExpression creation)
{
foreach(var keyvalue in creation.Items)
keyvalue.ValueExpression.AcceptWalker(this);
}
private void Format_Object_Creation_Expression(StringBuilder sb, ObjectCreationExpression oce)
{
sb.Append("new ");
if (oce.IsImplicitlyTyped == false)
{
sb.Append(FormatterUtility.FormatDataType(oce.ObjectType, document, controller));
}
// Figure out if this is a constructor call or array creation
// If it is an array then it needs the square brackets. Constructor calls
// with initialisers can omit the parentheses if there are no arguments.
string openingBrace = "[";
string closingBrace = "]";
bool isArrayCreation = false;
{
IToken startToken = document.Tokens.GetTokenAtOffset(oce.StartOffset);
TokenStream tokenStream = document.GetTokenStream(startToken);
while (startToken != null && startToken.StartOffset < oce.EndOffset)
{
string tokenText = document.GetSubstring(startToken.TextRange);
if (tokenText == "[")
{
isArrayCreation = true;
break;
}
if (tokenText == "(")
break;
if (tokenText == "{")
break; // If we get to the initialiser, we have gone too far.
startToken = tokenStream.Read();
}
if (isArrayCreation == false)
{
openingBrace = "(";
closingBrace = ")";
}
}
Process_Generic_Type_Arguments(sb, oce.GenericTypeArguments);
if (!isArrayCreation || (oce.Arguments != null && oce.Arguments.Count != 0) || oce.IsImplicitlyTyped)
{
sb.Append(openingBrace);
if (oce.Arguments != null)
{
for (int i = 0; i < oce.Arguments.Count; i++)
{
sb.Append(FormatExpression(oce.Arguments[i] as Expression));
if (oce.Arguments.Count > 1 && i < oce.Arguments.Count - 1)
sb.Append(", ");
}
}
sb.Append(closingBrace);
}
if (oce.Initializer != null)
sb.Append(FormatExpression(oce.Initializer));
}
