private ICodeNode ConvertNewArrayInit(MethodInvocationExpression invocation)
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
ArrayCreationExpression arrayCreation = GenerateArrayCreationExpression(invocation.Arguments[0]);
if (arrayCreation == null)
{
return(null);
}
ArrayCreationExpression initializerArray = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (initializerArray == null || initializerArray.Dimensions == null || initializerArray.Initializer == null || initializerArray.Initializer.Expressions == null ||
initializerArray.Initializer.Expressions.Count == 0)
{
return(null);
}
arrayCreation.Dimensions = initializerArray.Dimensions;
arrayCreation.Initializer = initializerArray.Initializer;
return(arrayCreation);
}
private ICodeNode ConvertListBind(MethodInvocationExpression invocation)
{
MethodReference methodRef;
if (invocation.Arguments.Count != 2 || !TryGetMethodReference((Expression)Visit(invocation.Arguments[0]), "System.Reflection.MethodInfo", out methodRef))
{
return(null);
}
PropertyDefinition propertyDef = ResolveProperty(methodRef);
if (propertyDef == null)
{
return(null);
}
ArrayCreationExpression listValues = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (listValues == null || listValues.Dimensions == null || listValues.Dimensions.Count != 1 || listValues.Initializer == null || listValues.Initializer.Expressions == null)
{
return(null);
}
listValues.Initializer.InitializerType = InitializerType.CollectionInitializer;
listValues.Initializer.IsMultiLine = true;
return(new BinaryExpression(BinaryOperator.Assign, new PropertyInitializerExpression(propertyDef, propertyDef.PropertyType),
listValues.Initializer, this.typeSystem, null));
}
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 void VisitArrayCreationExpression(ArrayCreationExpression node)
{
expressions.Push(ExpressionKind.None);
Visit(node.Dimensions);
expressions.Pop();
Visit(node.Initializer);
}
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 override void VisitBinaryExpression(BinaryExpression node)
{
base.VisitBinaryExpression(node);
if (node.Operator == BinaryOperator.Assign && node.Right.CodeNodeType == CodeNodeType.ArrayCreationExpression)
{
ArrayCreationExpression arrayCreation = node.Right as ArrayCreationExpression;
bool isInitializerPresent = Utilities.IsInitializerPresent(arrayCreation.Initializer);
if (node.Left.CodeNodeType == CodeNodeType.VariableDeclarationExpression)
{
VariableDeclarationExpression variableDeclaration = node.Left as VariableDeclarationExpression;
node.Left = new ArrayVariableDeclarationExpression(variableDeclaration, arrayCreation.ElementType,
arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null);
}
if (node.Left.CodeNodeType == CodeNodeType.VariableReferenceExpression)
{
VariableReferenceExpression variableReference = node.Left as VariableReferenceExpression;
node.Left = new ArrayVariableReferenceExpression(variableReference, arrayCreation.ElementType,
arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null);
}
if (node.Left.CodeNodeType == CodeNodeType.FieldReferenceExpression)
{
FieldReferenceExpression fieldReference = node.Left as FieldReferenceExpression;
node.Left = new ArrayAssignmentFieldReferenceExpression(fieldReference, arrayCreation.ElementType,
arrayCreation.Dimensions.CloneExpressionsOnly(), isInitializerPresent, null);
}
}
}
public override INode VisitArrayCreationExpression(ArrayCreationExpression arrayCreationExpression)
{
return(new ArrayCreationExpression(arrayCreationExpression.Context, arrayCreationExpression.Children.Select(Visit))
{
Type = arrayCreationExpression.Type
});
}
private ICodeNode ConvertCall(MethodInvocationExpression node)
{
MethodReference methodRef;
if (node.Arguments.Count < 2 || !TryGetMethodReference((Expression)Visit(node.Arguments[1]), "System.Reflection.MethodInfo", out methodRef))
{
return(null);
}
Expression target = GetTarget(node.Arguments[0]);
MethodInvocationExpression methodInvoke = new MethodInvocationExpression(new MethodReferenceExpression(target, methodRef, null), null);
if (node.Arguments.Count == 3)
{
ArrayCreationExpression arguments = Visit(node.Arguments[2]) as ArrayCreationExpression;
if (arguments == null || arguments.Dimensions.Count != 1 || arguments.Initializer == null || arguments.Initializer.Expressions == null ||
arguments.Initializer.Expressions.Count != methodRef.Parameters.Count)
{
return(null);
}
foreach (Expression argument in arguments.Initializer.Expressions)
{
methodInvoke.Arguments.Add(argument);
}
}
return(methodInvoke);
}
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;
}
public override Ust Visit(ArrayCreationExpression arrayCreationExpression)
{
Ust result;
if (arrayCreationExpression.Initializers?.All(i => i is StringLiteral) ?? false)
{
var value = new StringBuilder();
var textSpans = new List <TextSpan>();
foreach (StringLiteral stringLiteral in arrayCreationExpression.Initializers)
{
value.Append(stringLiteral.Text);
textSpans.Add(stringLiteral.TextSpan);
}
result = new StringLiteral(value.ToString(), textSpans.Union())
{
InitialTextSpans = textSpans
};
}
else
{
result = VisitChildren(arrayCreationExpression);
}
return(result);
}
private ICodeNode ConvertLambda(MethodInvocationExpression invocation)
{
if (invocation.Arguments.Count != 2)
{
return(null);
}
ArrayCreationExpression arguments = Visit(invocation.Arguments[1]) as ArrayCreationExpression;
if (arguments == null || arguments.Initializer == null || arguments.Initializer.Expressions == null ||
arguments.Initializer.Expressions.Any(element => element.CodeNodeType != CodeNodeType.ArgumentReferenceExpression))
{
return(null);
}
List <ArgumentReferenceExpression> parameters = arguments.Initializer.Expressions.Cast <ArgumentReferenceExpression>().ToList();
bool hasAnonymousParameter = parameters.Any(param => param.Parameter.ParameterType.Resolve().IsAnonymous());
BlockStatement body = new BlockStatement();
body.AddStatement(new ExpressionStatement(new ShortFormReturnExpression((Expression)Visit(invocation.Arguments[0]), null)));
return(new LambdaExpression(new ExpressionCollection(parameters.Select(param => new LambdaParameterExpression(param.Parameter, !hasAnonymousParameter, null))),
body, false, false, parameters.Select(argRef => argRef.Parameter), true, null));
}
public void Convert_JavaArrayInitialization()
{
var sourceCodeRep = new MemoryCodeRepository(
"class ArrayInitialization {\r\n" +
"public void init() {\r\n" +
"int[] arr1 = new int[] { 1, 2, 3 };\r\n" +
"int[][] arr2 = new int[1][2];\r\n" +
"int[][] arr3 = new int[1][];\r\n" +
"}\r\n" +
"}",
"ArrayInitialization.java"
);
var workflow = new Workflow(sourceCodeRep, stage: Stage.Ust)
{
IsSimplifyUst = false
};
var workflowResult = workflow.Process();
var ust = workflowResult.Usts.First();
var intType = new TypeToken("int");
var arrayData = new List <Tuple <List <Expression>, List <Expression> > >();
// new int[] { 1, 2, 3 };
arrayData.Add(new Tuple <List <Expression>, List <Expression> >(
Enumerable.Range(1, 3).Select(num => new IntLiteral(num)).ToList <Expression>(),
new List <Expression> {
new IntLiteral(0)
}
));
// new int[1][2];
arrayData.Add(new Tuple <List <Expression>, List <Expression> >(
null,
new List <Expression> {
new IntLiteral(1), new IntLiteral(2)
}
));
// new int[1][];
arrayData.Add(new Tuple <List <Expression>, List <Expression> >(
null,
new List <Expression> {
new IntLiteral(1), new IntLiteral(0)
}
));
for (var i = 0; i < arrayData.Count; i++)
{
var data = arrayData[i];
var arrayCreationExpression = new ArrayCreationExpression
{
Type = intType,
Initializers = data.Item1,
Sizes = data.Item2
};
bool exist = ust.AnyDescendant(node => node.Equals(arrayCreationExpression));
Assert.IsTrue(exist, "Test failed on " + i + " iteration.");
}
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
this.expressions.Push(0);
this.Visit(node.get_Dimensions());
dummyVar0 = this.expressions.Pop();
this.Visit(node.get_Initializer());
return;
}
public override ICodeNode VisitArrayCreationExpression(ArrayCreationExpression node)
{
V_0 = this.removePIDStep.VisitArrayCreationExpression(node);
if (V_0 != null)
{
return(V_0);
}
return(this.VisitArrayCreationExpression(node));
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
WriteKeyword("new");
WriteSpace();
WriteReference(node.Type);
WriteToken("[");
Visit(node.Dimensions);
WriteToken("]");
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
if (state == SearchState.Propagation)
{
canBePropagated = false;
return;
}
base.VisitArrayCreationExpression(node);
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
this.VisitArrayCreationExpression(node);
if (node.get_Initializer() != null)
{
V_0 = node.get_ExpressionType().Resolve();
this.AddArrayInitializerCasts(V_0, node.get_Initializer().get_Expression());
}
return;
}
public override void OnNewarr(Instruction instruction)
{
var creation = new ArrayCreationExpression(
(TypeReference)instruction.Operand,
new BlockExpression());
creation.Dimensions.Add(Pop());
Push(creation);
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
if (this.state == ExpressionPropagationStep.ExpressionTreeVisitor.SearchState.Propagation)
{
this.canBePropagated = false;
return;
}
this.VisitArrayCreationExpression(node);
return;
}
public override void VisitArrayCreationExpression(ArrayCreationExpression node)
{
base.VisitArrayCreationExpression(node);
if (node.Initializer != null)
{
TypeDefinition arrayType = node.ExpressionType.Resolve();
AddArrayInitializerCasts(arrayType, node.Initializer.Expression);
}
}
static dynamic handle(ArrayCreationExpression v)
{
List <dynamic> items = new List <dynamic>();
foreach (var expr in v.Initializer.Expressions)
{
items.Add(handle_dyn(expr));
}
return(items.ToArray());
}
public override ICodeNode VisitArrayCreationExpression(ArrayCreationExpression node)
{
ICodeNode newNode = removePIDStep.VisitArrayCreationExpression(node);
if (newNode != null)
{
return(newNode);
}
return(base.VisitArrayCreationExpression(node));
}
public override Ust VisitStackAllocArrayCreationExpression(StackAllocArrayCreationExpressionSyntax node)
{
var arrayTypeSyntax = (ArrayTypeSyntax)node.Type; // TODO: Fix it
var type = (TypeToken)base.Visit(node.Type);
var sizes = arrayTypeSyntax.RankSpecifiers
.SelectMany(rank => rank.Sizes.Select(s => (Expression)VisitAndReturnNullIfError(s))).ToArray();
var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan());
return(result);
}
/// <summary>
/// Generates the code for an <see cref="ArrayCreationExpression"/>.
/// </summary>
/// <param name="expression">The expression</param>
/// <returns>A BaZic code</returns>
private string GenerateArrayCreationExpression(ArrayCreationExpression expression)
{
var values = new List <string>();
foreach (var item in expression.Values)
{
values.Add(GenerateExpression(item));
}
return($"NEW [{string.Join(", ", values)}]");
}
public override Ust VisitImplicitArrayCreationExpression(ImplicitArrayCreationExpressionSyntax node)
{
var type = new TypeToken(CommonUtils.Prefix + "object", node.NewKeyword.GetTextSpan());
var sizes = node.Commas.Select(c => new IntLiteral(0, c.GetTextSpan())).ToList();
sizes.Add(new IntLiteral(0, node.CloseBracketToken.GetTextSpan()));
var result = new ArrayCreationExpression(type, sizes, new Expression[0], node.GetTextSpan());
return(result);
}
private uint GetCreatedArraySize(ArrayCreationExpression arrayCreation)
{
if (arrayCreation.get_Dimensions().get_Count() != 1)
{
throw new ArgumentOutOfRangeException("Expected one dimentional array creation.");
}
V_0 = arrayCreation.get_Dimensions().get_Item(0) as LiteralExpression;
if (V_0 == null)
{
throw new ArgumentOutOfRangeException("Expected constant-size array");
}
return(this.GetIndexFromLiteralExpression(V_0));
}
public override Ust VisitArrayCreationExpression(ArrayCreationExpressionSyntax node)
{
var type = ConvertType(base.Visit(node.Type.ElementType));
List <Expression> sizes = node.Type.RankSpecifiers
.SelectMany(rank => rank.Sizes.Select(s => (Expression)VisitAndReturnNullIfError(s))).ToList();
List <Expression> inits = node.Initializer != null
? node.Initializer.Expressions.Select(e => (Expression)VisitAndReturnNullIfError(e)).ToList()
: null;
var result = new ArrayCreationExpression(type, sizes, inits, node.GetTextSpan());
return(result);
}
private TypeReference GetUseInArrayCreation(ArrayCreationExpression arrayCreationExpression, VariableReference variable)
{
V_0 = arrayCreationExpression.get_Dimensions().GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_1 = V_0.get_Current();
if (V_1 as VariableReferenceExpression == null || (object)(V_1 as VariableReferenceExpression).get_Variable() != (object)variable)
{
continue;
}
V_2 = this.typeSystem.get_Int32();
goto Label0;
}
}
finally
{
if (V_0 != null)
{
V_0.Dispose();
}
}
V_0 = arrayCreationExpression.get_Initializer().get_Expressions().GetEnumerator();
try
{
while (V_0.MoveNext())
{
V_3 = V_0.get_Current();
if (V_3 as VariableReferenceExpression == null || (object)(V_3 as VariableReferenceExpression).get_Variable() != (object)variable)
{
continue;
}
V_2 = arrayCreationExpression.get_ElementType();
goto Label0;
}
goto Label1;
}
finally
{
if (V_0 != null)
{
V_0.Dispose();
}
}
Label0:
return(V_2);
Label1:
throw new ArgumentOutOfRangeException("Expression is not evaluated to any type.");
}
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);
}
private bool TryFillInitializer(ArrayCreationExpression expression, MemberHandleExpression values)
{
if (values.get_MemberReference() as FieldDefinition == null)
{
return(false);
}
V_0 = this.ConvertInitialValues((values.get_MemberReference() as FieldDefinition).get_InitialValue(), expression.get_ElementType().get_Name());
if (V_0 == null || !this.CheckElementsCount(V_0, expression.get_Dimensions()))
{
return(false);
}
this.RebuildDimensions(ref V_0, expression.get_Dimensions());
expression.get_Initializer().set_Expressions(V_0);
return(true);
}
