public ObjectCreationExpressionSyntax AddInitializerWithMapping(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingMatcher mappingMatcher,
ITypeSymbol createdObjectTyp,
MappingContext mappingContext,
MappingPath mappingPath = null)
{
var propertiesToSet = MappingTargetHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, mappingContext);
var assignments = MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingContext, mappingPath).ToList();
return(SyntaxFactoryExtensions.WithMembersInitialization(objectCreationExpression, assignments));
}
public async Task <ObjectCreationExpressionSyntax> AddInitializerWithMappingAsync(
ObjectCreationExpressionSyntax objectCreationExpression, IMappingMatcher mappingMatcher,
ITypeSymbol createdObjectTyp,
MappingContext mappingContext,
MappingPath mappingPath = null)
{
var propertiesToSet = _mappingTargetHelper.GetFieldsThaCanBeSetPublicly(createdObjectTyp, mappingContext);
var assignments = await MapUsingSimpleAssignment(propertiesToSet, mappingMatcher, mappingContext, mappingPath).ConfigureAwait(false);
return(SyntaxFactoryExtensions.WithMembersInitialization(objectCreationExpression, assignments));
}
public CompilationUnitSyntax ComputeRoot(CompilationUnitSyntax root)
{
var statement = SyntaxFactoryExtensions.ToReturnStatement(_property.ExpressionBody.Expression) as ReturnStatementSyntax;
var getter = AccessorDeclaration(GetAccessorDeclaration, Block(statement));
var newProperty = NodeExtensions.Nicefy(_property
.WithExpressionBody(null)
.WithAccessorList(AccessorList(new[] { getter }.ToSyntaxList()))
.WithSemicolon(None.ToToken()));
return(root.ReplaceNode(_property as SyntaxNode, newProperty as SyntaxNode));
}
private static SyntaxNode AddMaterializeCollectionInvocation(SyntaxGenerator generator, SyntaxNode sourceAccess, ITypeSymbol targetListType, bool isSourceNullable)
{
if (targetListType.TypeKind == TypeKind.Interface && targetListType.Name == "IEnumerable")
{
return(sourceAccess);
}
var materializeFunction = GetCollectionMaterializeFunction(targetListType);
var toListAccess = SyntaxFactoryExtensions.CreateMemberAccessExpression((ExpressionSyntax)sourceAccess, isSourceNullable, materializeFunction);
return(generator.InvocationExpression(toListAccess));
}
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
CheckCastContex(node);
CheckParenthesizeContex(node);
var newNode = SyntaxFactoryExtensions.DataCodeVirtualAccess();
string name = node.Identifier.Text;
string typeText = "";
bool found = false;
VirtualData virtualData = null;
foreach (var data in _virtualizationContext.data)
{
if (data.Name.Equals(name))
{
typeText = data.Type;
found = true;
virtualData = data;
break;
}
}
if (!found)
{
return(node);
}
newNode = newNode.WithAdditionalAnnotations(virtualData.Annotations);
var newExpression = newNode;
if (CastEnabled)
{
newExpression = SyntaxFactory.CastExpression(SyntaxFactory.IdentifierName
(
@"" + typeText
),
newNode
);
}
if (ParenthesizeEnabled)
{
newExpression = SyntaxFactory.ParenthesizedExpression(newExpression);
}
newExpression = newExpression.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia())
;
return(newExpression);
}
public override SyntaxNode VisitBinaryExpression(BinaryExpressionSyntax node)
{
node = (BinaryExpressionSyntax)base.VisitBinaryExpression(node);
if ((node.Kind() != SyntaxKind.AddExpression) &&
(node.Kind() != SyntaxKind.SubtractExpression)
)
{
return(node);
}
if (node.Parent.Kind() == SyntaxKind.SimpleAssignmentExpression)
{
bottomUp = 0;
return(node);
}
if (node.Parent.Kind() == SyntaxKind.EqualsValueClause)
{
bottomUp = 0;
return(node);
}
int markedNodesCount = markedNodes.Count();
if (markedNodesCount > 0)
{
bottomUp++;
return(node);
}
if (bottomUp + 2 < VirtualizationContext.MAX_OPERANDS)
{
bottomUp++;
return(node);
}
string tempName = VAR_NAME + VAR_COUNTER++;
var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, node);
var tempIdentifier = SyntaxFactory.IdentifierName(tempName);
var tuple = new Tuple <ExpressionSyntax, IdentifierNameSyntax, SyntaxNode>(node, tempIdentifier, tempVar);
var parent = GetParentExpression(node);
markedNodes.Add(parent);
replacementNodes.Add(tuple);
bottomUp++;
return(node);
}
/// <summary>
/// If the method is void, in order to exit the interpreter, the body of the method must contain a return statement with random expression;
/// </summary>
/// <param name="leadingTrivia"></param>
/// <param name="oldBody"></param>
/// <returns>return 1;</returns>
private BlockSyntax AddReturnToVoidMethod(BlockSyntax oldBody)
{
var expression = SyntaxFactoryExtensions.NumericLiteralExpression(_virtualizationContext.DataIndexFake);
//class level interpreter
var returnStatement = SyntaxFactory.ReturnStatement(expression).NormalizeWhitespace();
if (_virtualizationContext.MethodLevelOn)
{
returnStatement = SyntaxFactory.ReturnStatement();
}
var list = oldBody.Statements;
list = list.Add(returnStatement);
oldBody = oldBody.WithStatements(list);
return(oldBody);
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
string declaredType = node.Declaration.Type.ToString();
bool basicType = SyntaxFactoryExtensions.IsBasicType(declaredType);
if (!basicType)
{
return(node);
}
if (declaredType.Equals("int"))
{
return(node);
}
if (declaredType.Equals("bool"))
{
return(node);
}
if (declaredType.Equals("char"))
{
return(node);
}
if (declaredType.Equals("string"))
{
return(node);
}
foreach (var variable in node.Declaration.Variables)
{
if (variable.Initializer == null)
{
continue;
}
var oldRightValue = variable.Initializer.Value;
markedNodes.Add(oldRightValue);
var newRightValue = SyntaxFactory.BinaryExpression(SyntaxKind.AddExpression, oldRightValue,
SyntaxFactoryExtensions.DefaultValue(declaredType));
replacementNodes.Add(new Tuple <ExpressionSyntax, ExpressionSyntax> (oldRightValue, newRightValue));
}
return(node);
}
public override SyntaxNode VisitSwitchStatement(SwitchStatementSyntax node)
{
node = (SwitchStatementSyntax)base.VisitSwitchStatement(node);
var condition = node.Expression;
if (condition.Kind() == SyntaxKind.IdentifierName)
{
return(node);
}
string conditionVarIdentifier = ConditionIdentifier;
var newConditionVar = SyntaxFactoryExtensions.LocalVariableDeclaration(conditionVarIdentifier,
condition).NormalizeWhitespace().WithTriviaFrom(node);
var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(condition);
markedNodes.Add(condition);
replacementNodes.Add(new Tuple <ExpressionSyntax, IdentifierNameSyntax, StatementSyntax>(condition, newCondition, newConditionVar));
return(node);
}
//STEP 1
public override SyntaxNode VisitWhileStatement(WhileStatementSyntax node)
{
var nodeVisited = (WhileStatementSyntax)base.VisitWhileStatement(node);
var condition = nodeVisited.Condition;
if (condition.Kind() == SyntaxKind.IdentifierName)
{
return(nodeVisited);
}
string conditionVarIdentifier = ConditionIdentifier;
var newConditionVar = SyntaxFactoryExtensions.GenerateLocalVariableDeclaration(conditionVarIdentifier,
condition, SyntaxKind.BoolKeyword).NormalizeWhitespace().WithTriviaFrom(nodeVisited);
var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(condition);
markedNodes.Add(condition);
markedNodes.Add(node);
replacementNodes.Add(new Tuple <ExpressionSyntax, IdentifierNameSyntax, StatementSyntax, WhileStatementSyntax>(condition, newCondition, newConditionVar, node));
return(nodeVisited);
}
private List <StatementSyntax> VirtualizationInterpreter(SyntaxTrivia leadingTrivia, VirtualizationContext context)
{
List <StatementSyntax> statements = new List <StatementSyntax>();
var switchStatement =
SyntaxFactoryExtensions.SwitchBlockStatement(leadingTrivia, context)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)
);
var whileTrueStatement = SyntaxFactoryExtensions.WhileTrue(leadingTrivia,
new StatementSyntax[] { switchStatement })
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine),
SyntaxFactory.EndOfLine(Environment.NewLine));
statements.Add(whileTrueStatement);
var returnStatement = SyntaxFactoryExtensions.ReturnStatement("object")
.WithLeadingTrivia(leadingTrivia)
.WithTrailingTrivia(SyntaxFactory.EndOfLine(Environment.NewLine)).NormalizeWhitespace();
statements.Add(returnStatement);
return(statements);
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
node = (LocalDeclarationStatementSyntax)base.VisitLocalDeclarationStatement(node);
if (node.Declaration.Variables.Count != 1)
{
return(node);
}
if (!node.Declaration.Type.ToString().Equals("var"))
{
return(node);
}
var identifier = node.Declaration.Variables.First().Identifier.ValueText;
var initializerValue = node.Declaration.Variables.First().Initializer.Value;
var typeInfo = _virtualizationContext.semanticModel.GetTypeInfo(initializerValue).Type;
string type = typeInfo.ToString();
markedNodes.Add(node);
var newVar = SyntaxFactoryExtensions.LocalVariableDeclaration(identifier, initializerValue, type);
return(newVar);
}
public override SyntaxNode VisitDoStatement(DoStatementSyntax node)
{
currentWhileNode = node;
continueStatements.Add(currentWhileNode, new List <SyntaxNode>());
breakStatements.Add(currentWhileNode, new List <SyntaxNode>());
var nodeVisited = (DoStatementSyntax)base.VisitDoStatement(node);
var condition = nodeVisited.Condition;
if (condition.Kind() == SyntaxKind.IdentifierName) //check if the code was formatted before to while(condition)
{
return(nodeVisited); //return if already refactored
}
string conditionVarIdentifier = ConditionIdentifier;
var newConditionVar = SyntaxFactoryExtensions.LocalVariableDeclaration(conditionVarIdentifier,
condition, SyntaxKind.BoolKeyword).NormalizeWhitespace().WithTriviaFrom(nodeVisited);
var newCondition = SyntaxFactory.IdentifierName(conditionVarIdentifier).WithTriviaFrom(condition);
markedNodes.Add(condition);
markedNodes.Add(node);
whileReplacementNodes.Add(new Tuple <ExpressionSyntax, IdentifierNameSyntax, StatementSyntax, DoStatementSyntax>(condition, newCondition, newConditionVar, node));
return(nodeVisited);
}
/// <summary>
/// Returns syntax for the static fields of the serializer class.
/// </summary>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the static fields of the serializer class.</returns>
private static MemberDeclarationSyntax[] GenerateStaticFields(List <FieldInfoMember> fields)
{
var result = new List <MemberDeclarationSyntax>();
// ReSharper disable once ReturnValueOfPureMethodIsNotUsed
Expression <Action <TypeInfo> > getField = _ => _.GetField(string.Empty, BindingFlags.Default);
Expression <Action <Type> > getTypeInfo = _ => _.GetTypeInfo();
Expression <Action> getGetter = () => SerializationManager.GetGetter(default(FieldInfo));
Expression <Action> getReferenceSetter = () => SerializationManager.GetReferenceSetter(default(FieldInfo));
Expression <Action> getValueSetter = () => SerializationManager.GetValueSetter(default(FieldInfo));
// Expressions for specifying binding flags.
var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax(
SyntaxKind.BitwiseOrExpression,
BindingFlags.Instance,
BindingFlags.NonPublic,
BindingFlags.Public);
// Add each field and initialize it.
foreach (var field in fields)
{
var fieldInfo =
getField.Invoke(getTypeInfo.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax())))
.AddArgumentListArguments(
SF.Argument(field.FieldInfo.Name.GetLiteralExpression()),
SF.Argument(bindingFlags));
var fieldInfoVariable =
SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo));
var fieldInfoField = SF.IdentifierName(field.InfoFieldName);
if (!field.IsGettableProperty || !field.IsSettableProperty)
{
result.Add(
SF.FieldDeclaration(
SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
// Declare the getter for this field.
if (!field.IsGettableProperty)
{
var getterType =
typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldGetterVariable =
SF.VariableDeclarator(field.GetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
getterType,
getGetter.Invoke().AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(getterType).AddVariables(fieldGetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (!field.IsSettableProperty)
{
if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.IsValueType)
{
var setterType =
typeof(SerializationManager.ValueTypeSetter <,>).MakeGenericType(
field.FieldInfo.DeclaringType,
field.FieldInfo.FieldType).GetTypeSyntax();
var fieldSetterVariable =
SF.VariableDeclarator(field.SetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
setterType,
getValueSetter.Invoke()
.AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
else
{
var setterType =
typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var fieldSetterVariable =
SF.VariableDeclarator(field.SetterFieldName)
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(
setterType,
getReferenceSetter.Invoke()
.AddArgumentListArguments(SF.Argument(fieldInfoField)))));
result.Add(
SF.FieldDeclaration(SF.VariableDeclaration(setterType).AddVariables(fieldSetterVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
}
}
return(result.ToArray());
}
/// <summary>
/// Returns syntax for initializing a new instance of the provided type.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>Syntax for initializing a new instance of the provided type.</returns>
private static ExpressionSyntax GetObjectCreationExpressionSyntax(Type type)
{
ExpressionSyntax result;
var typeInfo = type.GetTypeInfo();
if (typeInfo.IsValueType)
{
// Use the default value.
result = SF.DefaultExpression(typeInfo.GetTypeSyntax());
}
else if (type.GetConstructor(Type.EmptyTypes) != null)
{
// Use the default constructor.
result = SF.ObjectCreationExpression(typeInfo.GetTypeSyntax()).AddArgumentListArguments();
}
else
{
// Create an unformatted object.
#if DNXCORE50
var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax(
SyntaxKind.BitwiseOrExpression,
BindingFlags.Instance,
BindingFlags.NonPublic,
BindingFlags.Public);
var nullLiteralExpressionArgument = SF.Argument(SF.LiteralExpression(SyntaxKind.NullLiteralExpression));
var typeArg = SF.Argument(SF.TypeOfExpression(typeInfo.GetTypeSyntax()));
var bindingFlagsArg = SF.Argument(bindingFlags);
var binderArg = nullLiteralExpressionArgument;
ArgumentSyntax ctorArgumentsArg;
var cons = typeInfo.GetConstructors(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
.OrderBy(p => p.GetParameters().Count()).FirstOrDefault();
var consParameters = cons != null?cons.GetParameters().Select(p => p.ParameterType).ToArray() : null;
if (consParameters != null && consParameters.Length > 0)
{
var separatedSyntaxList = new SeparatedSyntaxList <ExpressionSyntax>();
separatedSyntaxList = consParameters
.Aggregate(separatedSyntaxList, (current, t) => current.Add(SF.DefaultExpression(t.GetTypeInfo().GetTypeSyntax())));
ctorArgumentsArg = SF.Argument(separatedSyntaxList.GetArrayCreationWithInitializerSyntax(
SF.PredefinedType(SF.Token(SyntaxKind.ObjectKeyword))));
}
else
{
ctorArgumentsArg = nullLiteralExpressionArgument;
}
var cultureInfoArg = SF.Argument(
SF.IdentifierName("System").Member("Globalization").Member("CultureInfo").Member("InvariantCulture"));
var createInstanceArguments = new []
{
typeArg,
bindingFlagsArg,
binderArg,
ctorArgumentsArg,
cultureInfoArg
};
Expression <Func <object> > getUninitializedObject = () => Activator.CreateInstance(
default(Type),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public,
null,
null,
System.Globalization.CultureInfo.InvariantCulture);
result = SF.CastExpression(
type.GetTypeSyntax(),
getUninitializedObject.Invoke()
.AddArgumentListArguments(createInstanceArguments));
#else
Expression <Func <object> > getUninitializedObject =
() => FormatterServices.GetUninitializedObject(default(Type));
result = SF.CastExpression(
type.GetTypeSyntax(),
getUninitializedObject.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(typeInfo.GetTypeSyntax()))));
#endif
}
return(result);
}
public override SyntaxNode VisitPrefixUnaryExpression(PrefixUnaryExpressionSyntax node)
{
if (node.Kind() != SyntaxKind.UnaryMinusExpression)
{
return(base.VisitPrefixUnaryExpression(node));
}
var expression = node.Operand;
if (expression.Kind() != SyntaxKind.NumericLiteralExpression)
{
return(base.VisitPrefixUnaryExpression(node));
}
CheckCastContex(node);
string value = node.ToString();
bool found = false;
VirtualData constant = null;
foreach (var data in _virtualizationContext.data)
{
if (value.Equals(data.Name))
{
found = true;
constant = data;
break;
}
}
if (!found)
{
int index = _virtualizationContext.DataIndex;
string name = value;
SyntaxAnnotation indexMarker = new SyntaxAnnotation("index", index + "");
SyntaxAnnotation nameMarker = new SyntaxAnnotation("name", name);
SyntaxAnnotation constantMarker = new SyntaxAnnotation("type", "constant");
SyntaxAnnotation codeMarker = new SyntaxAnnotation("code", "undefined");
SyntaxAnnotation uniqueMarker = new SyntaxAnnotation("unique", "" + VirtualizationContext.UniqueId);
constant = new VirtualData();
constant.Index = index;
constant.Name = name;
var typeInfo = _virtualizationContext.semanticModel.GetTypeInfo(node);
var info = typeInfo.Type.ToString();
constant.Type = info;
constant.Node = node;
constant.DefaultValue = node;
constant.Annotations.Add(indexMarker);
constant.Annotations.Add(nameMarker);
constant.Annotations.Add(constantMarker);
constant.Annotations.Add(codeMarker);
constant.Annotations.Add(uniqueMarker);
_virtualizationContext.data.Add(constant);
}
// constants.Add(node);
ExpressionSyntax newNode = SyntaxFactoryExtensions.DataCodeVirtualAccess();
newNode = newNode.WithAdditionalAnnotations(constant.Annotations);
ExpressionSyntax newExpression;
if (CastEnabled)
{
newExpression = SyntaxFactory.CastExpression(SyntaxFactory.IdentifierName
(
@"" + constant.Type
),
newNode
);
}
else
{
newExpression = newNode;
}
//TODO: add annotations + comments
newExpression = newExpression.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia())
;
return(newExpression);
}
public override SyntaxNode VisitLiteralExpression(LiteralExpressionSyntax node)
{
var kind = node.Kind();
if ((kind != SyntaxKind.NumericLiteralExpression) &&
(kind != SyntaxKind.StringLiteralExpression) &&
(kind != SyntaxKind.FalseLiteralExpression) &&
(kind != SyntaxKind.TrueLiteralExpression) &&
(kind != SyntaxKind.CharacterLiteralExpression)
)
{
return(node);
}
CheckCastContex(node);
string value = node.ToString();
bool found = false;
VirtualData constant = null;
string requiredType = GetRequiredType(node); //in the case of return statements
if (requiredType.Equals("void"))
{
requiredType = ""; // return statement was added as a refactoring "hack"
}
var typeInfo = _virtualizationContext.semanticModel.GetTypeInfo(node);
var declaredType = typeInfo.Type.ToString();
foreach (var data in _virtualizationContext.data)
{
if (value.Equals(data.Name))
{
if (requiredType.Equals("") && declaredType.Equals(data.Type))
{
found = true;
constant = data;
requiredType = declaredType;
break;
}
if (requiredType.Equals(data.Type))
{
found = true;
constant = data;
break;
}
}
}
if (!found)
{
if (requiredType.Equals(""))
{
requiredType = declaredType;
}
int index = _virtualizationContext.DataIndex;
string name = value;
SyntaxAnnotation dataIndexMarker = new SyntaxAnnotation("index", index + "");
SyntaxAnnotation nameMarker = new SyntaxAnnotation("name", name);
SyntaxAnnotation constantMarker = new SyntaxAnnotation("type", "constant");
SyntaxAnnotation codeIndexMarker = new SyntaxAnnotation("code", "undefined");
SyntaxAnnotation uniqueMarker = new SyntaxAnnotation("unique", "" + VirtualizationContext.UniqueId);
constant = new VirtualData();
constant.Index = index;
constant.Name = name;
var info = requiredType;
constant.Type = info;
constant.Node = node;
constant.DefaultValue = node;
constant.Annotations.Add(dataIndexMarker);
constant.Annotations.Add(nameMarker);
constant.Annotations.Add(constantMarker);
constant.Annotations.Add(codeIndexMarker);
constant.Annotations.Add(uniqueMarker);
_virtualizationContext.data.Add(constant);
}
ExpressionSyntax newNode = SyntaxFactoryExtensions.DataCodeVirtualAccess();
newNode = newNode.WithAdditionalAnnotations(constant.Annotations);
ExpressionSyntax newExpression;
if (CastEnabled)
{
newExpression = SyntaxFactory.CastExpression(SyntaxFactory.IdentifierName
(
@"" + constant.Type
),
newNode
);
}
else
{
newExpression = newNode;
}
//TODO: add annotations + comments
newExpression = newExpression.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(node.GetTrailingTrivia())
;
return(newExpression);
}
private BlockSyntax ReplaceNodes(BlockSyntax oldBody)
{
List <SyntaxNode> nodesToTrack = this.markedNodes;
var continueSts = continueStatements.SelectMany(x => x.Value);
var breakSts = breakStatements.SelectMany(x => x.Value);
nodesToTrack.AddRange(continueSts);
nodesToTrack.AddRange(breakSts);
oldBody = oldBody.TrackNodes(nodesToTrack);
foreach (var tuple in this.whileReplacementNodes)
{
var currentA = oldBody.GetCurrentNode(tuple.Item1);
if (currentA != null)
{
//create new statement
var localCondition = tuple.Item3 as LocalDeclarationStatementSyntax;
var initializer = localCondition.Declaration.Variables.First();
var updateCondition = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(initializer.Identifier), initializer.Initializer.Value));
var whileStatement = currentA.Parent;
oldBody = oldBody.InsertNodesBefore(whileStatement, new List <SyntaxNode>()
{
tuple.Item3
});
var currentB = oldBody.GetCurrentNode(tuple.Item1);
oldBody = oldBody.ReplaceNode(currentB, tuple.Item2);
//update continue statements
foreach (var cont in continueStatements[tuple.Item4])
{
var currentContinue = oldBody.GetCurrentNode(cont);
oldBody = oldBody.ReplaceNode(currentContinue, new List <SyntaxNode>()
{
updateCondition, cont
});
}
//update break statements
foreach (var brk in breakStatements[tuple.Item4])
{
var currentBreak = oldBody.GetCurrentNode(brk);
var invalidateCondition = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SyntaxFactory.IdentifierName(initializer.Identifier), SyntaxFactoryExtensions.BooleanLiteralExpression(false)));
oldBody = oldBody.ReplaceNode(currentBreak, new List <SyntaxNode>()
{
invalidateCondition, SyntaxFactory.ContinueStatement()
});
}
var currentWhile = oldBody.GetCurrentNode(tuple.Item4);
//modify body
var whileBody = currentWhile.Statement as BlockSyntax;
var newStatements = whileBody.Statements.Add(updateCondition);
whileBody = whileBody.WithStatements(newStatements);
//updateWhile
var newWhile = currentWhile.WithStatement(whileBody);
oldBody = oldBody.ReplaceNode(currentWhile, newWhile);
}
}
return(oldBody);
}
/// <summary>
/// index = index - 1;
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
private ExpressionStatementSyntax DecrementIndex(ExpressionSyntax operand)
{
var rightExpression = SyntaxFactory.BinaryExpression(SyntaxKind.SubtractExpression, operand, SyntaxFactoryExtensions.NumericLiteralExpression(1));
var incrementedVariable = SyntaxFactory.ExpressionStatement(SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, operand, rightExpression));
return(incrementedVariable);
}
private static MemberDeclarationSyntax GenerateConstructor(string className, List <FieldInfoMember> fields)
{
var body = new List <StatementSyntax>();
Expression <Action <TypeInfo> > getField = _ => _.GetField(string.Empty, BindingFlags.Default);
Expression <Action <Type> > getTypeInfo = _ => _.GetTypeInfo();
Expression <Action <IFieldUtils> > getGetter = _ => _.GetGetter(default(FieldInfo));
Expression <Action <IFieldUtils> > getReferenceSetter = _ => _.GetReferenceSetter(default(FieldInfo));
Expression <Action <IFieldUtils> > getValueSetter = _ => _.GetValueSetter(default(FieldInfo));
// Expressions for specifying binding flags.
var bindingFlags = SyntaxFactoryExtensions.GetBindingFlagsParenthesizedExpressionSyntax(
SyntaxKind.BitwiseOrExpression,
BindingFlags.Instance,
BindingFlags.NonPublic,
BindingFlags.Public);
var fieldUtils = SF.IdentifierName("fieldUtils");
foreach (var field in fields)
{
// Get the field
var fieldInfoField = SF.IdentifierName(field.InfoFieldName);
var fieldInfo =
getField.Invoke(getTypeInfo.Invoke(SF.TypeOfExpression(field.FieldInfo.DeclaringType.GetTypeSyntax())))
.AddArgumentListArguments(
SF.Argument(field.FieldInfo.Name.GetLiteralExpression()),
SF.Argument(bindingFlags));
var fieldInfoVariable =
SF.VariableDeclarator(field.InfoFieldName).WithInitializer(SF.EqualsValueClause(fieldInfo));
if (!field.IsGettableProperty || !field.IsSettableProperty)
{
body.Add(SF.LocalDeclarationStatement(
SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable)));
}
// Set the getter/setter of the field
if (!field.IsGettableProperty)
{
var getterType =
typeof(Func <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var getterInvoke = SF.CastExpression(
getterType,
getGetter.Invoke(fieldUtils).AddArgumentListArguments(SF.Argument(fieldInfoField)));
body.Add(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(field.GetterFieldName), getterInvoke)));
}
if (!field.IsSettableProperty)
{
if (field.FieldInfo.DeclaringType != null && field.FieldInfo.DeclaringType.GetTypeInfo().IsValueType)
{
var setterType =
typeof(ValueTypeSetter <,>).MakeGenericType(
field.FieldInfo.DeclaringType,
field.FieldInfo.FieldType).GetTypeSyntax();
var getValueSetterInvoke = SF.CastExpression(
setterType,
getValueSetter.Invoke(fieldUtils)
.AddArgumentListArguments(SF.Argument(fieldInfoField)));
body.Add(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(field.SetterFieldName), getValueSetterInvoke)));
}
else
{
var setterType =
typeof(Action <,>).MakeGenericType(field.FieldInfo.DeclaringType, field.FieldInfo.FieldType)
.GetTypeSyntax();
var getReferenceSetterInvoke = SF.CastExpression(
setterType,
getReferenceSetter.Invoke(fieldUtils)
.AddArgumentListArguments(SF.Argument(fieldInfoField)));
body.Add(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, SF.IdentifierName(field.SetterFieldName), getReferenceSetterInvoke)));
}
}
}
return
(SF.ConstructorDeclaration(className)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.AddParameterListParameters(
SF.Parameter(fieldUtils.Identifier).WithType(typeof(IFieldUtils).GetTypeSyntax()))
.AddBodyStatements(body.ToArray()));
}
private StatementSyntax SectionToIf(ExpressionSyntax condition, SwitchSectionSyntax section)
{
SwitchBreakRefactoringVisitor breakRefactoring = new SwitchBreakRefactoringVisitor();
var bodyList = section.Statements.First();
bodyList = (StatementSyntax)breakRefactoring.Visit(bodyList);
bool hasDefault = false;
List <ExpressionSyntax> labelExpressions = new List <ExpressionSyntax>();
foreach (var label in section.Labels)
{
if (label.Keyword.Kind() == SyntaxKind.DefaultKeyword)
{
hasDefault = true;
}
foreach (var child in label.ChildNodes())
{
var labelCondition = (ExpressionSyntax)child;
if ((labelCondition.Kind() != SyntaxKind.NumericLiteralExpression) ||
(labelCondition.Kind() != SyntaxKind.StringLiteralExpression) ||
(labelCondition.Kind() != SyntaxKind.CharacterLiteralExpression) ||
(labelCondition.Kind() != SyntaxKind.SimpleMemberAccessExpression)
)
{
labelCondition = SyntaxFactory.ParenthesizedExpression(labelCondition).WithTriviaFrom(labelCondition);
}
labelExpressions.Add(labelCondition);
break;
}
}
List <ExpressionSyntax> flagConditions = new List <ExpressionSyntax>();
foreach (var expression in labelExpressions)
{
var memberAccess = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, condition,
SyntaxFactory.IdentifierName("Equals"));
var arg = SyntaxFactory.Argument(expression);
var argList = SyntaxFactory.SeparatedList <ArgumentSyntax>(new List <ArgumentSyntax>()
{
arg
});
var invocation = SyntaxFactory.InvocationExpression(memberAccess, SyntaxFactory.ArgumentList(argList));
flagConditions.Add(invocation);
}
ExpressionSyntax ifCondition = SyntaxFactoryExtensions.BooleanLiteralExpression(true);
if (flagConditions.Count == 1)
{
ifCondition = flagConditions[0];
}
BinaryExpressionSyntax boolCondition = null;
for (int i = 1; i < flagConditions.Count; i++)
{
var right = flagConditions[i];
if (boolCondition == null)
{
boolCondition = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, flagConditions[0], right);
}
else
{
boolCondition = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, boolCondition, right);
}
ifCondition = boolCondition;
}
if (hasDefault)
{
// ifCondition = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalOrExpression, ifCondition, SyntaxFactoryExtensions.BooleanLiteralExpression(true));
return(bodyList);
}
var ifStatement = SyntaxFactory.IfStatement(ifCondition, bodyList);
return(ifStatement);
}
public SyntaxNode VisitPrePostExpression(PrefixUnaryExpressionSyntax pre, PostfixUnaryExpressionSyntax post)
{
SyntaxNode node = null;
if (pre == null)
{
node = post;
}
if (post == null)
{
node = pre;
}
if (node == null)
{
return(node);
}
bool postDecr = (node.Kind() == SyntaxKind.PostDecrementExpression);
bool postIncr = (node.Kind() == SyntaxKind.PostIncrementExpression);
bool preDecr = (node.Kind() == SyntaxKind.PreDecrementExpression);
bool preIncr = (node.Kind() == SyntaxKind.PreIncrementExpression);
bool condition = postDecr || postIncr || preDecr || preIncr;
if (!condition)
{
return(node);
}
int markedNodesCount = markedNodes.Count();
if (markedNodesCount > 0)
{
return(node);
}
ExpressionSyntax operand = null;
int operationType = 0; // 0 - pre, 1 - post
if (postDecr || postIncr)
{
operationType = 1;
operand = ((PostfixUnaryExpressionSyntax)node).Operand;
}
else
{
operand = ((PrefixUnaryExpressionSyntax)node).Operand;
}
string tempName = TemporaryVarIdentifier + "_" + operationType;
StatementSyntax indexUpdate = null;
if (postIncr || preIncr)
{
indexUpdate = IncrementIndex(operand);
}
else if (postDecr || preDecr)
{
indexUpdate = DecrementIndex(operand);
}
var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, operand);
var tempIdentifier = SyntaxFactory.IdentifierName(tempName);
var tuple = new Tuple <SyntaxNode, IdentifierNameSyntax, int, SyntaxNode, SyntaxNode>(node, tempIdentifier, operationType, tempVar, indexUpdate);
var parent = GetParentExpression(node);
markedNodes.Add(parent);
replacementNodes.Add(tuple);
return(node);
}
private MappingElement ConvertToSimpleType(AnnotatedType targetType, MappingElement source, MappingContext mappingContext)
{
var conversion = semanticModel.Compilation.ClassifyConversion(source.ExpressionType.Type, targetType.Type);
if (conversion.Exists == false)
{
var wrapper = GetWrappingInfo(source.ExpressionType.Type, targetType.Type, mappingContext);
if (wrapper.Type == WrapperInfoType.ObjectField)
{
return(new MappingElement
{
Expression = SyntaxFactoryExtensions.CreateMemberAccessExpression(source.Expression, source.ExpressionType.CanBeNull, wrapper.UnwrappingObjectField.Name),
ExpressionType = wrapper.UnwrappingObjectField.Type
});
}
if (wrapper.Type == WrapperInfoType.Method)
{
return(new MappingElement
{
Expression = SyntaxFactoryExtensions.CreateMethodAccessExpression(source.Expression, source.ExpressionType.CanBeNull, wrapper.UnwrappingMethod.Name),
ExpressionType = new AnnotatedType(wrapper.UnwrappingMethod.ReturnType)
});
}
if (targetType.Type.SpecialType == SpecialType.System_String && source.ExpressionType.Type.TypeKind == TypeKind.Enum)
{
var toStringAccess = SyntaxFactoryExtensions.CreateMethodAccessExpression(source.Expression, source.ExpressionType.CanBeNull, "ToString");
return(new MappingElement
{
Expression = toStringAccess,
ExpressionType = targetType
});
}
if (source.ExpressionType.Type.SpecialType == SpecialType.System_String && targetType.Type.TypeKind == TypeKind.Enum)
{
var parseEnumAccess = syntaxGenerator.MemberAccessExpression(SyntaxFactory.ParseTypeName("System.Enum"), "Parse");
var enumType = SyntaxFactory.ParseTypeName(targetType.Type.Name);
var parseInvocation = (InvocationExpressionSyntax)syntaxGenerator.InvocationExpression(parseEnumAccess, new[]
{
syntaxGenerator.TypeOfExpression(enumType),
source.Expression,
syntaxGenerator.TrueLiteralExpression()
});
return(new MappingElement()
{
Expression = (ExpressionSyntax)syntaxGenerator.CastExpression(enumType, parseInvocation),
ExpressionType = targetType.AsNotNull()
});
}
}
else if (conversion.IsExplicit)
{
return(new MappingElement()
{
Expression = (ExpressionSyntax)syntaxGenerator.CastExpression(targetType.Type, source.Expression),
ExpressionType = targetType
});
}
return(source);
}
public override SyntaxNode VisitMemberAccessExpression(MemberAccessExpressionSyntax node)
{
node = (MemberAccessExpressionSyntax)base.VisitMemberAccessExpression(node);
if ((node.Kind() != SyntaxKind.SimpleMemberAccessExpression))
{
return(node);
}
//only one invocation is skipped.
if (node.Parent.Kind() == SyntaxKind.SimpleAssignmentExpression)
{
bottomUp = 0;
return(node);
}
if (node.Parent.Kind() == SyntaxKind.InvocationExpression)
{
bottomUp = 0;
return(node);
}
if (node.Parent.Kind() == SyntaxKind.EqualsValueClause)
{
bottomUp = 0;
return(node);
}
if (node.Parent.Kind() == SyntaxKind.Block)
{
bottomUp = 0;
return(node);
}
if (node.Parent.Kind() == SyntaxKind.ExpressionStatement)
{
if (node.Parent.Parent.Kind() == SyntaxKind.Block)
{
bottomUp = 0;
return(node);
}
}
int markedNodesCount = markedNodes.Count();
if (markedNodesCount > 0)
{
bottomUp++;
return(node);
}
if (bottomUp + 2 < VirtualizationContext.MAX_OPERANDS)
{
bottomUp++;
// return node;
}
string tempName = TemporaryVarIdentifier;
var tempVar = SyntaxFactoryExtensions.LocalVariableDeclaration(tempName, node);
var tempIdentifier = SyntaxFactory.IdentifierName(tempName);
var tuple = new Tuple <ExpressionSyntax, IdentifierNameSyntax, SyntaxNode>(node, tempIdentifier, tempVar);
var parent = GetParentExpression(node);
markedNodes.Add(parent);
replacementNodes.Add(tuple);
bottomUp++;
return(node);
}
public override SyntaxNode VisitLocalDeclarationStatement(LocalDeclarationStatementSyntax node)
{
var declaration = node;
List <StatementSyntax> statements = new List <StatementSyntax>();
markedNodes.Add(node);
foreach (var variable in declaration.Declaration.Variables)
{
int index = _virtualizationContext.DataIndex;
string name = variable.Identifier.Text;
SyntaxAnnotation indexMarker = new SyntaxAnnotation("index", index + "");
SyntaxAnnotation nameMarker = new SyntaxAnnotation("name", name);
SyntaxAnnotation variableMarker = new SyntaxAnnotation("type", "variable");
SyntaxAnnotation codeIndexMarker = new SyntaxAnnotation("code", "undefined");
SyntaxAnnotation uniqueMarker = new SyntaxAnnotation("unique", "" + VirtualizationContext.UniqueId);
var virtualData = new VirtualData();
virtualData.Type = declaration.Declaration.Type.ToString();
virtualData.Index = index;
virtualData.Name = name;
virtualData.Annotations.Add(indexMarker);
virtualData.Annotations.Add(nameMarker);
virtualData.Annotations.Add(variableMarker);
virtualData.Annotations.Add(codeIndexMarker);
virtualData.Annotations.Add(uniqueMarker);
_virtualizationContext.data.Add(virtualData);
//TODO: split for multiple variables in the same declaration
var initializer = variable.Initializer;
if (initializer == null)
{
continue;
}
SyntaxNode rightValue;
rightValue = initializer.DescendantNodes().First();
ExpressionStatementSyntax newNode;
if (SyntaxFactoryExtensions.IsBasicType(virtualData.Type))
{
newNode = SyntaxFactoryExtensions.DataVirtualAssignment(rightValue, virtualData.Annotations.ToArray())
.WithLeadingTrivia(declaration.GetLeadingTrivia())
.WithTrailingTrivia(declaration.GetTrailingTrivia())
;
}
else
{
newNode = SyntaxFactoryExtensions.DataVirtualAssignment(virtualData.Type, rightValue, virtualData.Annotations.ToArray())
.WithLeadingTrivia(declaration.GetLeadingTrivia())
.WithTrailingTrivia(declaration.GetTrailingTrivia())
;
}
virtualData.Node = newNode;
virtualData.Statement = newNode;
statements.Add(newNode);
}
replacementNodes.Add(new Tuple <LocalDeclarationStatementSyntax, List <StatementSyntax> >(node, statements));
return(node);
}
