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); }