private async Task <ExpressionSyntax> ConvertToStringComparisonOperatorAsync(VBSyntax.BinaryExpressionSyntax node, SyntaxKind expressionKind) { var(lhs, rhs) = await AcceptSidesAsync(node); lhs = VisualBasicEqualityComparison.VbCoerceToString(lhs, _semanticModel.GetTypeInfo(node.Left)); rhs = VisualBasicEqualityComparison.VbCoerceToString(rhs, _semanticModel.GetTypeInfo(node.Right)); var member = new KnownMethod(_compilerServices, _operators, "CompareString"); var optionaCompareTextBoolLiteralExpression = _visualBasicEqualityComparison.OptionCompareTextCaseInsensitiveBoolExpression; var comparedLhs = member.Invoke(_visualBasicEqualityComparison.ExtraUsingDirectives, lhs, rhs, optionaCompareTextBoolLiteralExpression); return(SyntaxFactory.BinaryExpression(expressionKind, comparedLhs, LiteralConversions.GetLiteralExpression(0))); }
private static ExpressionSyntax IncreaseArrayUpperBoundExpression(VBSyntax.ExpressionSyntax expr, SemanticModel model, VBasic.VisualBasicSyntaxVisitor <CSharpSyntaxNode> commentConvertingNodesVisitor) { var constant = model.GetConstantValue(expr); if (constant.HasValue && constant.Value is int) { return(SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal((int)constant.Value + 1))); } return(SyntaxFactory.BinaryExpression( SyntaxKind.SubtractExpression, (ExpressionSyntax)expr.Accept(commentConvertingNodesVisitor), SyntaxFactory.Token(SyntaxKind.PlusToken), SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))); }
private ForStatementSyntax CreateForZeroToValueLoop(SimpleNameSyntax loopVariableIdentifier, StatementSyntax loopStatement, ExpressionSyntax inclusiveLoopUpperBound) { var loopVariableAssignment = CreateVariableDeclarationAndAssignment(loopVariableIdentifier.Identifier.Text, CommonConversions.Literal(0)); var lessThanSourceBounds = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, loopVariableIdentifier, inclusiveLoopUpperBound); var incrementors = SyntaxFactory.SingletonSeparatedList <ExpressionSyntax>( SyntaxFactory.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, loopVariableIdentifier)); var forStatementSyntax = SyntaxFactory.ForStatement(loopVariableAssignment, SyntaxFactory.SeparatedList <ExpressionSyntax>(), lessThanSourceBounds, incrementors, loopStatement); return(forStatementSyntax); }
private ExpressionSyntax IncreaseArrayUpperBoundExpression(VBSyntax.ExpressionSyntax expr) { var constant = _semanticModel.GetConstantValue(expr); if (constant.HasValue && constant.Value is int) { return(SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal((int)constant.Value + 1))); } return(SyntaxFactory.BinaryExpression( Microsoft.CodeAnalysis.CSharp.SyntaxKind.SubtractExpression, (ExpressionSyntax)expr.Accept(_nodesVisitor), SyntaxFactory.Token(Microsoft.CodeAnalysis.CSharp.SyntaxKind.PlusToken), SyntaxFactory.LiteralExpression(Microsoft.CodeAnalysis.CSharp.SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(1)))); }
/// <summary> /// Returns syntax for retrieving the value of this field, deep copying it if neccessary. /// </summary> /// <param name="instance">The instance of the containing type.</param> /// <param name="forceAvoidCopy">Whether or not to ensure that no copy of the field is made.</param> /// <returns>Syntax for retrieving the value of this field.</returns> public ExpressionSyntax GetGetter(ExpressionSyntax instance, bool forceAvoidCopy = false) { // Retrieve the value of the field. var getValueExpression = this.GetValueExpression(instance); // Avoid deep-copying the field if possible. if (forceAvoidCopy || this.FieldInfo.FieldType.IsOrleansShallowCopyable()) { // Return the value without deep-copying it. return(getValueExpression); } // Addressable arguments must be converted to references before passing. // IGrainObserver instances cannot be directly converted to references, therefore they are not included. ExpressionSyntax deepCopyValueExpression; if (typeof(IAddressable).IsAssignableFrom(this.FieldInfo.FieldType) && this.FieldInfo.FieldType.GetTypeInfo().IsInterface && !typeof(IGrainObserver).IsAssignableFrom(this.FieldInfo.FieldType)) { var getAsReference = getValueExpression.Member( (IAddressable grain) => grain.AsReference <IGrain>(), this.FieldInfo.FieldType); // If the value is not a GrainReference, convert it to a strongly-typed GrainReference. // C#: !(value is GrainReference) ? value.AsReference<TInterface>() : value; deepCopyValueExpression = SF.ConditionalExpression( SF.PrefixUnaryExpression( SyntaxKind.LogicalNotExpression, SF.ParenthesizedExpression( SF.BinaryExpression( SyntaxKind.IsExpression, getValueExpression, typeof(GrainReference).GetTypeSyntax()))), SF.InvocationExpression(getAsReference), getValueExpression); } else { deepCopyValueExpression = getValueExpression; } // Deep-copy the value. Expression <Action> deepCopyInner = () => SerializationManager.DeepCopyInner(default(object)); var typeSyntax = this.FieldInfo.FieldType.GetTypeSyntax(); return(SF.CastExpression( typeSyntax, deepCopyInner.Invoke().AddArgumentListArguments(SF.Argument(deepCopyValueExpression)))); }
/// <summary> /// Cut down version of Microsoft.VisualBasic.CompilerServices.Utils.CopyArray /// </summary> private IfStatementSyntax CreateConditionalArrayCopy(IdentifierNameSyntax sourceArrayExpression, ExpressionSyntax targetArrayExpression, List <ExpressionSyntax> convertedBounds) { var sourceLength = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, sourceArrayExpression, SyntaxFactory.IdentifierName("Length")); var arrayCopyStatement = convertedBounds.Count == 1 ? CreateArrayCopyWithMinOfLengths(sourceArrayExpression, sourceLength, targetArrayExpression, convertedBounds.Single()) : CreateArrayCopy(sourceArrayExpression, sourceLength, targetArrayExpression, convertedBounds); var oldTargetNotEqualToNull = SyntaxFactory.BinaryExpression(SyntaxKind.NotEqualsExpression, sourceArrayExpression, SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)); return(SyntaxFactory.IfStatement(oldTargetNotEqualToNull, arrayCopyStatement)); }
private static void BarOutput(InstanceConnector output, InstanceConnection <SyntaxNode> connection, Scope scope) { Assert.IsNotNull(connection.OutputNode); Assert.IsNotNull(connection.InputNode); Assert.IsInstanceOfType(connection.InputNode, typeof(ExpressionSyntax)); Assert.IsInstanceOfType(connection.OutputNode, typeof(ExpressionSyntax)); scope.AddInstanceInitializer(FooInputInit.Get( connection.Source, CSharp.ParseExpression('"' + connection.Input.Id + '"'), CSharp.BinaryExpression(SyntaxKind.EqualsExpression, (ExpressionSyntax)connection.InputNode, (ExpressionSyntax)connection.OutputNode))); }
/// <summary> /// Returns syntax for the options argument to <see cref="GrainReference.InvokeMethodAsync{T}"/> and <see cref="GrainReference.InvokeOneWayMethod"/>. /// </summary> /// <param name="method">The method which an invoke call is being generated for.</param> /// <returns> /// Argument syntax for the options argument to <see cref="GrainReference.InvokeMethodAsync{T}"/> and /// <see cref="GrainReference.InvokeOneWayMethod"/>, or <see langword="null"/> if no options are to be specified. /// </returns> private static ArgumentSyntax GetInvokeOptions(MethodInfo method) { var options = new List <ExpressionSyntax>(); if (GrainInterfaceUtils.IsReadOnly(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.ReadOnly.ToString())); } if (GrainInterfaceUtils.IsUnordered(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.Unordered.ToString())); } if (GrainInterfaceUtils.IsAlwaysInterleave(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.AlwaysInterleave.ToString())); } if (GrainInterfaceUtils.IsNewTransactionRequired(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionRequiresNew.ToString())); } if (GrainInterfaceUtils.IsTransactionRequired(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionRequired.ToString())); } ExpressionSyntax allOptions; if (options.Count <= 1) { allOptions = options.FirstOrDefault(); } else { allOptions = options.Aggregate((a, b) => SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, a, b)); } if (allOptions == null) { return(null); } return(SF.Argument(SF.NameColon("options"), SF.Token(SyntaxKind.None), allOptions)); }
private ExpressionSyntax AddTypeConversion(VBSyntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded, ITypeSymbol vbType, ITypeSymbol vbConvertedType) { switch (conversionKind) { case TypeConversionKind.FractionalNumberRoundThenCast: csNode = AddRoundInvocation(vbNode, csNode, vbType, vbConvertedType); return(AddTypeConversion(vbNode, csNode, TypeConversionKind.NonDestructiveCast, addParenthesisIfNeeded, vbType, vbConvertedType)); case TypeConversionKind.EnumConversionThenCast: var underlyingType = ((INamedTypeSymbol)vbConvertedType).EnumUnderlyingType; csNode = AddTypeConversion(vbNode, csNode, TypeConversionKind.Conversion, addParenthesisIfNeeded, vbType, underlyingType); return(AddTypeConversion(vbNode, csNode, TypeConversionKind.NonDestructiveCast, addParenthesisIfNeeded, underlyingType, vbConvertedType)); case TypeConversionKind.EnumCastThenConversion: var enumUnderlyingType = ((INamedTypeSymbol)vbType).EnumUnderlyingType; csNode = AddTypeConversion(vbNode, csNode, TypeConversionKind.NonDestructiveCast, addParenthesisIfNeeded, vbType, enumUnderlyingType); return(AddTypeConversion(vbNode, csNode, TypeConversionKind.Conversion, addParenthesisIfNeeded, enumUnderlyingType, vbConvertedType)); case TypeConversionKind.Unknown: case TypeConversionKind.Identity: return(addParenthesisIfNeeded ? vbNode.ParenthesizeIfPrecedenceCouldChange(csNode) : csNode); case TypeConversionKind.DestructiveCast: case TypeConversionKind.NonDestructiveCast: return(CreateCast(csNode, vbConvertedType)); case TypeConversionKind.Conversion: return(AddExplicitConvertTo(vbNode, csNode, vbType, vbConvertedType));; case TypeConversionKind.NullableBool: return(SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csNode, LiteralConversions.GetLiteralExpression(true))); case TypeConversionKind.StringToCharArray: var memberAccessExpressionSyntax = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, csNode, SyntaxFactory.IdentifierName(nameof(string.ToCharArray))); return(SyntaxFactory.InvocationExpression(memberAccessExpressionSyntax, SyntaxFactory.ArgumentList())); case TypeConversionKind.DelegateConstructor: return(SyntaxFactory.ObjectCreationExpression(GetCommonDelegateTypeOrNull(vbNode, vbConvertedType)).WithArgumentList(new[] { csNode }.CreateCsArgList())); default: throw new ArgumentOutOfRangeException(); } }
protected virtual IfStatementSyntax GenerateIfBsonTypeNull() { return(SF.IfStatement( condition: SF.BinaryExpression( SyntaxKind.EqualsExpression, Basics.TryParseBsonTypeIdentifier, SF.Token(SyntaxKind.EqualsEqualsToken), Basics.NumberLiteral(10) ), statement: SF.Block( SF.ExpressionStatement( SF.AssignmentExpression( kind: SyntaxKind.SimpleAssignmentExpression, left: Basics.SimpleMemberAccess(Basics.TryParseOutVariableIdentifier, Basics.IdentifierName(MemberDecl.DeclSymbol)), right: SF.LiteralExpression(SyntaxKind.DefaultLiteralExpression)) ), SF.ContinueStatement()) )); }
public static MethodDeclarationSyntax MakeWithMethod(string className, IEnumerable <Field> fields) { var withMethodParameters = SF.ParameterList( SF.SeparatedList( fields.Select( field => SF.Parameter(SF.Identifier(field.Name)) .WithType( field.IsNonNullable ? SF.NullableType(field.Type) : field.Type ) .WithDefault( SF.EqualsValueClause( SF.Token(SyntaxKind.EqualsToken), SF.LiteralExpression(SyntaxKind.NullLiteralExpression)))))); var withMethodBodyStatements = fields.Select( field => SF.Argument( SF.BinaryExpression( SyntaxKind.CoalesceExpression, SF.IdentifierName(field.Name), SF.MemberAccessExpression( SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name))))); return (SF.MethodDeclaration( SF.ParseTypeName(className), "With" ) .WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) })) .WithParameterList(withMethodParameters) .WithBody( SF.Block( SF.ReturnStatement( SF.ObjectCreationExpression( SF.IdentifierName(className), SF.ArgumentList(SF.SeparatedList(withMethodBodyStatements)), null))))); }
private MemberDeclarationSyntax MockProviderMethod() { var m = F.MethodDeclaration(MockMemberType, F.Identifier(MemberMockName)).WithTypeParameterList(TypeParameterList()); m = m.WithModifiers(F.TokenList(F.Token(SyntaxKind.PublicKeyword))); var keyCreation = F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables(F.SingletonSeparatedList(F .VariableDeclarator(F.Identifier("key")).WithInitializer(F.EqualsValueClause(TypesOfTypeParameters()))))); var mockCreation = F.SimpleLambdaExpression(F.Parameter(F.Identifier("keyString")), F.ObjectCreationExpression(MockMemberType) .WithExpressionsAsArgumentList( F.ThisExpression(), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(ClassSymbol.Name)), F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(InterfaceSymbol.Name)), F.BinaryExpression(SyntaxKind.AddExpression, F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(Symbol.Name)), F.IdentifierName("keyString")), F.BinaryExpression(SyntaxKind.AddExpression, F.BinaryExpression(SyntaxKind.AddExpression, F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(MemberMockName)), F.IdentifierName("keyString")), F.LiteralExpression( SyntaxKind.StringLiteralExpression, F.Literal("()"))), StrictnessExpression() )); var returnStatement = F.ReturnStatement(F.CastExpression(MockMemberType, F.InvocationExpression( F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(MockProviderName), F.IdentifierName("GetOrAdd"))) .WithArgumentList( F.ArgumentList(F.SeparatedList(new[] { F.Argument(F.IdentifierName("key")), F.Argument(mockCreation) }))))); m = m.WithBody(F.Block(keyCreation, returnStatement)); var constraints = TypesForSymbols.AsConstraintClauses(Symbol.TypeParameters); if (constraints.Any()) { m = m.AddConstraintClauses(constraints); } return(m); }
public ExpressionSyntax GetRoslynExpression(RoslynExpressionContext context) { var manager = context.GetService(typeof(IGuildOptionsManager)); var optionsType = context.ExpectedType.GetGenericArguments()[0]; var typeSyntax = S.ParseTypeName(optionsType.FullName.Replace('+', '.')); var getName = S.GenericName(nameof(SettingExtensions.GetOptionsAsync)).WithTypeArgumentList(S.TypeArgumentList().AddArguments(typeSyntax)); var get = S.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, manager, getName); var guildId = S.BinaryExpression( SyntaxKind.CoalesceExpression, context.GetRequestProperty(nameof(MessageRequest.GuildId)), S.ThrowExpression(S.ObjectCreationExpression( S.IdentifierName("InvalidOperationException"), S.ArgumentList().AddArguments(S.Argument(S.LiteralExpression(SyntaxKind.StringLiteralExpression, S.Literal(GuildIdNotDefined)))), null )) ); var invoke = S.InvocationExpression(get, S.ArgumentList().AddArguments(S.Argument(guildId))); return(S.AwaitExpression(invoke)); }
private static MemberDeclarationSyntax[] GetFieldInfoFields(List <FieldInfoMember> fields) { var result = new List <MemberDeclarationSyntax>(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Expression <Action <Type> > getField = _ => _.GetField(string.Empty, BindingFlags.Default); // Expressions for specifying binding flags. var flags = SF.IdentifierName("System").Member("Reflection").Member("BindingFlags"); var publicFlag = flags.Member(BindingFlags.Public.ToString()); var nonPublicFlag = flags.Member(BindingFlags.NonPublic.ToString()); var instanceFlag = flags.Member(BindingFlags.Instance.ToString()); var bindingFlags = SF.ParenthesizedExpression( SF.BinaryExpression( SyntaxKind.BitwiseOrExpression, publicFlag, SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, nonPublicFlag, instanceFlag))); // Add each field and initialize it. foreach (var field in fields) { var fieldInfo = getField.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)); result.Add( SF.FieldDeclaration( SF.VariableDeclaration(typeof(FieldInfo).GetTypeSyntax()).AddVariables(fieldInfoVariable)) .AddModifiers( SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.StaticKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword))); } return(result.ToArray()); }
public ExpressionSyntax VisitExpression(ExpressionSyntax node) { if (node is BinaryExpressionSyntax binaryExpression) { var left = VisitExpression(binaryExpression.Left); var right = VisitExpression(binaryExpression.Right); return(SF.BinaryExpression(node.Kind(), left, right)); } if (node is IdentifierNameSyntax identifierName) { return(SMS.Variables[identifierName.Identifier.Text]); } if (node is CastExpressionSyntax castExpression) { return(SF.CastExpression(castExpression.Type, VisitExpression(castExpression.Expression))); } if (node is InvocationExpressionSyntax invocationExpression) { var arguments = SF.ArgumentList(); foreach (var a in invocationExpression.ArgumentList.Arguments) { arguments = arguments.AddArguments(VisitArgument(a)); } return(SF.InvocationExpression(invocationExpression.Expression, arguments)); } if (node is PrefixUnaryExpressionSyntax prefixUnaryExpression) { return(SF.PrefixUnaryExpression(node.Kind(), VisitExpression(prefixUnaryExpression.Operand))); } if (node is ParenthesizedExpressionSyntax parenthesizedExpressionSyntax) { return(SF.ParenthesizedExpression(VisitExpression(parenthesizedExpressionSyntax.Expression))); } if (node is LiteralExpressionSyntax || node is MemberAccessExpressionSyntax) { return(node); } throw new NotImplementedException(node.GetType().Name); }
public ExpressionSyntax ToExpression() { if (this.Expression != null) { return(this.Expression); } switch (this.Operator.OperatorType) { case OperatorTypes.Parenthesis: return(SF.ParenthesizedExpression(Right.ToExpression())); case OperatorTypes.Power: return(MethodCallContext.CreateMethodCall("Pow", false, new ArgumentSyntax[] { SF.Argument(Left.ToExpression()), SF.Argument(Right.ToExpression()) })); case OperatorTypes.IsIn: return(MethodCallContext.CreateMethodCall("IsIn", false, new ArgumentSyntax[] { SF.Argument(Left.ToExpression()), SF.Argument(Right.ToExpression()) })); case OperatorTypes.Contains: return(MethodCallContext.CreateMethodCall("Contains", false, new ArgumentSyntax[] { SF.Argument(Left.ToExpression()), SF.Argument(Right.ToExpression()) })); case OperatorTypes.Index: return(MethodCallContext.CreateMethodCall("Index", false, new ArgumentSyntax[] { SF.Argument(Left.ToExpression()), SF.Argument(Right.ToExpression()) })); case OperatorTypes.IndexOf: return(MethodCallContext.CreateMethodCall("Index", false, new ArgumentSyntax[] { SF.Argument(Right.ToExpression()), SF.Argument(Left.ToExpression()) })); case OperatorTypes.LastIndex: return(MethodCallContext.CreateMethodCall("IndexFromLast", false, new ArgumentSyntax[] { SF.Argument(Left.ToExpression()), SF.Argument(Right.ToExpression()) })); case OperatorTypes.LastIndexOf: return(MethodCallContext.CreateMethodCall("IndexFromLast", false, new ArgumentSyntax[] { SF.Argument(Right.ToExpression()), SF.Argument(Left.ToExpression()) })); case OperatorTypes.Noop: return(Right.ToExpression()); default: return(SF.BinaryExpression(this.Operator.SyntaxKind, Left.ToExpression(), Right.ToExpression())); } }
public ExpressionSyntax AddExplicitConversion(Microsoft.CodeAnalysis.VisualBasic.Syntax.ExpressionSyntax vbNode, ExpressionSyntax csNode, TypeConversionKind conversionKind, bool addParenthesisIfNeeded = false, bool isConst = false, ITypeSymbol forceTargetType = null) { var typeInfo = ModelExtensions.GetTypeInfo(_semanticModel, vbNode); var vbType = typeInfo.Type; var vbConvertedType = forceTargetType ?? typeInfo.ConvertedType; if (isConst && _expressionEvaluator.GetConstantOrNull(vbNode, vbConvertedType, csNode) is ExpressionSyntax constLiteral) { return(constLiteral); } switch (conversionKind) { case TypeConversionKind.Unknown: case TypeConversionKind.Identity: return(addParenthesisIfNeeded ? VbSyntaxNodeExtensions.ParenthesizeIfPrecedenceCouldChange(vbNode, csNode) : csNode); case TypeConversionKind.DestructiveCast: case TypeConversionKind.NonDestructiveCast: return(CreateCast(csNode, vbConvertedType)); case TypeConversionKind.Conversion: return(AddExplicitConvertTo(vbNode, csNode, vbType, vbConvertedType));; case TypeConversionKind.NullableBool: return(SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, csNode, LiteralConversions.GetLiteralExpression(true))); case TypeConversionKind.StringToCharArray: var memberAccessExpressionSyntax = SyntaxFactory.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, csNode, SyntaxFactory.IdentifierName(nameof(string.ToCharArray))); return(SyntaxFactory.InvocationExpression(memberAccessExpressionSyntax, SyntaxFactory.ArgumentList())); default: throw new ArgumentOutOfRangeException(); } }
/// <summary> /// Returns syntax for the options argument to <see cref="GrainReference.InvokeMethodAsync{T}"/> and <see cref="GrainReference.InvokeOneWayMethod"/>. /// </summary> /// <param name="method">The method which an invoke call is being generated for.</param> /// <returns> /// Argument syntax for the options argument to <see cref="GrainReference.InvokeMethodAsync{T}"/> and /// <see cref="GrainReference.InvokeOneWayMethod"/>, or <see langword="null"/> if no options are to be specified. /// </returns> private static ArgumentSyntax GetInvokeOptions(MethodInfo method) { var options = new List <ExpressionSyntax>(); if (GrainInterfaceUtils.IsReadOnly(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.ReadOnly.ToString())); } if (GrainInterfaceUtils.IsUnordered(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.Unordered.ToString())); } if (GrainInterfaceUtils.IsAlwaysInterleave(method)) { options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.AlwaysInterleave.ToString())); } if (GrainInterfaceUtils.TryGetTransactionOption(method, out TransactionOption option)) { switch (option) { case TransactionOption.Suppress: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionSuppress.ToString())); break; case TransactionOption.CreateOrJoin: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionCreateOrJoin.ToString())); break; case TransactionOption.Create: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionCreate.ToString())); break; case TransactionOption.Join: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionJoin.ToString())); break; case TransactionOption.Supported: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionSupported.ToString())); break; case TransactionOption.NotAllowed: options.Add(typeof(InvokeMethodOptions).GetNameSyntax().Member(InvokeMethodOptions.TransactionNotAllowed.ToString())); break; default: throw new NotSupportedException($"Transaction option {options} is not supported."); } } ExpressionSyntax allOptions; if (options.Count <= 1) { allOptions = options.FirstOrDefault(); } else { allOptions = options.Aggregate((a, b) => SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, a, b)); } if (allOptions == null) { return(null); } return(SF.Argument(SF.NameColon("options"), SF.Token(SyntaxKind.None), allOptions)); }
public override SyntaxList <StatementSyntax> VisitSelectBlock(VBSyntax.SelectBlockSyntax node) { var expr = (ExpressionSyntax)node.SelectStatement.Expression.Accept(_nodesVisitor); var exprWithoutTrivia = expr.WithoutTrivia().WithoutAnnotations(); var sections = new List <SwitchSectionSyntax>(); foreach (var block in node.CaseBlocks) { var labels = new List <SwitchLabelSyntax>(); foreach (var c in block.CaseStatement.Cases) { if (c is VBSyntax.SimpleCaseClauseSyntax s) { var originalExpressionSyntax = (ExpressionSyntax)s.Value.Accept(_nodesVisitor); var expressionSyntax = CommonConversions.TypeConversionAnalyzer.AddExplicitConversion(s.Value, originalExpressionSyntax); SwitchLabelSyntax caseSwitchLabelSyntax = SyntaxFactory.CaseSwitchLabel(expressionSyntax); if (!_semanticModel.GetConstantValue(s.Value).HasValue || originalExpressionSyntax != expressionSyntax) { caseSwitchLabelSyntax = WrapInCasePatternSwitchLabelSyntax(node, expressionSyntax); } labels.Add(caseSwitchLabelSyntax); } else if (c is VBSyntax.ElseCaseClauseSyntax) { labels.Add(SyntaxFactory.DefaultSwitchLabel()); } else if (c is VBSyntax.RelationalCaseClauseSyntax relational) { var operatorKind = VBasic.VisualBasicExtensions.Kind(relational); var cSharpSyntaxNode = SyntaxFactory.BinaryExpression(operatorKind.ConvertToken(TokenContext.Local), exprWithoutTrivia, (ExpressionSyntax)relational.Value.Accept(_nodesVisitor)); labels.Add(WrapInCasePatternSwitchLabelSyntax(node, cSharpSyntaxNode, treatAsBoolean: true)); } else if (c is VBSyntax.RangeCaseClauseSyntax range) { var lowerBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, (ExpressionSyntax)range.LowerBound.Accept(_nodesVisitor), exprWithoutTrivia); var upperBoundCheck = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, exprWithoutTrivia, (ExpressionSyntax)range.UpperBound.Accept(_nodesVisitor)); var withinBounds = SyntaxFactory.BinaryExpression(SyntaxKind.LogicalAndExpression, lowerBoundCheck, upperBoundCheck); labels.Add(WrapInCasePatternSwitchLabelSyntax(node, withinBounds, treatAsBoolean: true)); } else { throw new NotSupportedException(c.Kind().ToString()); } } var csBlockStatements = block.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor)).ToList(); if (csBlockStatements.LastOrDefault() ?.IsKind(SyntaxKind.ReturnStatement) != true) { csBlockStatements.Add(SyntaxFactory.BreakStatement()); } var list = SingleStatement(SyntaxFactory.Block(csBlockStatements)); sections.Add(SyntaxFactory.SwitchSection(SyntaxFactory.List(labels), list)); } var switchStatementSyntax = ValidSyntaxFactory.SwitchStatement(expr, sections); return(SingleStatement(switchStatementSyntax)); }
/// <summary> /// Generates switch cases for the provided grain type. /// </summary> /// <param name="grainType"> /// The grain type. /// </param> /// <param name="methodIdArgument"> /// The method id argument, which is used to select the correct switch label. /// </param> /// <param name="generateMethodHandler"> /// The function used to generate switch block statements for each method. /// </param> /// <returns> /// The switch cases for the provided grain type. /// </returns> public static SwitchSectionSyntax[] GenerateGrainInterfaceAndMethodSwitch( Type grainType, IdentifierNameSyntax methodIdArgument, Func <MethodInfo, StatementSyntax[]> generateMethodHandler) { var interfaces = GrainInterfaceData.GetRemoteInterfaces(grainType); interfaces[GrainInterfaceData.GetGrainInterfaceId(grainType)] = grainType; // Switch on interface id. var interfaceCases = new List <SwitchSectionSyntax>(); foreach (var @interface in interfaces) { var interfaceType = @interface.Value; var interfaceId = @interface.Key; var methods = GrainInterfaceData.GetMethods(interfaceType); var methodCases = new List <SwitchSectionSyntax>(); // Switch on method id. foreach (var method in methods) { // Generate switch case. var methodId = GrainInterfaceData.ComputeMethodId(method); var methodType = method; // Generate the switch label for this interface id. var methodIdSwitchLabel = SF.CaseSwitchLabel( SF.LiteralExpression(SyntaxKind.NumericLiteralExpression, SF.Literal(methodId))); // Generate the switch body. var methodInvokeStatement = generateMethodHandler(methodType); methodCases.Add( SF.SwitchSection().AddLabels(methodIdSwitchLabel).AddStatements(methodInvokeStatement)); } // Generate the switch label for this interface id. var interfaceIdSwitchLabel = SF.CaseSwitchLabel( SF.LiteralExpression(SyntaxKind.NumericLiteralExpression, SF.Literal(interfaceId))); // Generate the default case, which will throw a NotImplementedException. var errorMessage = SF.BinaryExpression( SyntaxKind.AddExpression, "interfaceId=".GetLiteralExpression(), SF.BinaryExpression( SyntaxKind.AddExpression, SF.LiteralExpression(SyntaxKind.NumericLiteralExpression, SF.Literal(interfaceId)), SF.BinaryExpression( SyntaxKind.AddExpression, ",methodId=".GetLiteralExpression(), methodIdArgument))); var throwStatement = SF.ThrowStatement( SF.ObjectCreationExpression(typeof(NotImplementedException).GetTypeSyntax()) .AddArgumentListArguments(SF.Argument(errorMessage))); var defaultCase = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(throwStatement); // Generate switch statements for the methods in this interface. var methodSwitchStatements = SF.SwitchStatement(methodIdArgument).AddSections(methodCases.ToArray()).AddSections(defaultCase); // Generate the switch section for this interface. interfaceCases.Add( SF.SwitchSection().AddLabels(interfaceIdSwitchLabel).AddStatements(methodSwitchStatements)); } return(interfaceCases.ToArray()); }
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node) { var stmt = node.ForStatement; ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor); VariableDeclarationSyntax declaration = null; ExpressionSyntax id; if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax) { var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable; declaration = CommonConversions.SplitVariableDeclarations(v).Values.Single(); declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue)))); id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier); } else { id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor); var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol; if (symbol != null && !_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any()) { declaration = CommonConversions.CreateVariableDeclarationAndAssignment(symbol.Name, startValue); } else { startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue); } } var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor); PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax; ExpressionSyntax condition; // In Visual Basic, the To expression is only evaluated once, but in C# will be evaluated every loop. // If it could evaluate differently or has side effects, it must be extracted as a variable var preLoopStatements = new List <SyntaxNode>(); var csToValue = (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor); if (!_semanticModel.GetConstantValue(stmt.ToValue).HasValue) { var loopToVariableName = GetUniqueVariableNameInScope(node, "loopTo"); var loopEndDeclaration = SyntaxFactory.LocalDeclarationStatement(CommonConversions.CreateVariableDeclarationAndAssignment(loopToVariableName, csToValue)); // Does not do anything about porting newline trivia upwards to maintain spacing above the loop preLoopStatements.Add(loopEndDeclaration); csToValue = SyntaxFactory.IdentifierName(loopToVariableName); } ; if (value == null) { condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, csToValue); } else { condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, csToValue); } if (step == null) { step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id); } else { step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step); } var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor))); var forStatementSyntax = SyntaxFactory.ForStatement( declaration, declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue), condition, SyntaxFactory.SingletonSeparatedList(step), block.UnpackNonNestedBlock()); return(SyntaxFactory.List(preLoopStatements.Concat(new[] { forStatementSyntax }))); }
/// <summary> /// Generates syntax for an invoke method. /// </summary> /// <param name="grainType"> /// The grain type. /// </param> /// <param name="invokeMethod"> /// The invoke method to generate. /// </param> /// <returns> /// Syntax for an invoke method. /// </returns> private static MethodDeclarationSyntax GenerateInvokeMethod(Type grainType, MethodInfo invokeMethod) { var parameters = invokeMethod.GetParameters(); var grainArgument = parameters[0].Name.ToIdentifierName(); var requestArgument = parameters[1].Name.ToIdentifierName(); // Store the relevant values from the request in local variables. var interfaceIdDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(int).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("interfaceId") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.InterfaceId))))); var interfaceIdVariable = SF.IdentifierName("interfaceId"); var methodIdDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(int).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("methodId") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.MethodId))))); var methodIdVariable = SF.IdentifierName("methodId"); var argumentsDeclaration = SF.LocalDeclarationStatement( SF.VariableDeclaration(typeof(object[]).GetTypeSyntax()) .AddVariables( SF.VariableDeclarator("arguments") .WithInitializer(SF.EqualsValueClause(requestArgument.Member((InvokeMethodRequest _) => _.Arguments))))); var argumentsVariable = SF.IdentifierName("arguments"); var methodDeclaration = invokeMethod.GetDeclarationSyntax() .AddBodyStatements(interfaceIdDeclaration, methodIdDeclaration, argumentsDeclaration); var interfaceCases = CodeGeneratorCommon.GenerateGrainInterfaceAndMethodSwitch( grainType, methodIdVariable, methodType => GenerateInvokeForMethod(grainType, grainArgument, methodType, argumentsVariable)); // Generate the default case, which will throw a NotImplementedException. var errorMessage = SF.BinaryExpression( SyntaxKind.AddExpression, "interfaceId=".GetLiteralExpression(), interfaceIdVariable); var throwStatement = SF.ThrowStatement( SF.ObjectCreationExpression(typeof(NotImplementedException).GetTypeSyntax()) .AddArgumentListArguments(SF.Argument(errorMessage))); var defaultCase = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(throwStatement); var interfaceIdSwitch = SF.SwitchStatement(interfaceIdVariable).AddSections(interfaceCases.ToArray()).AddSections(defaultCase); // If the provided grain is null, throw an argument exception. var argumentNullException = SF.ObjectCreationExpression(typeof(ArgumentNullException).GetTypeSyntax()) .AddArgumentListArguments(SF.Argument(parameters[0].Name.GetLiteralExpression())); var grainArgumentCheck = SF.IfStatement( SF.BinaryExpression( SyntaxKind.EqualsExpression, grainArgument, SF.LiteralExpression(SyntaxKind.NullLiteralExpression)), SF.ThrowStatement(argumentNullException)); return(methodDeclaration.AddBodyStatements(grainArgumentCheck, interfaceIdSwitch)); }
private ExpressionSyntax BuildXmlnsAttributeName(IdentifierNameSyntax fieldIdentifierName) { var xmlns = SyntaxFactory.MemberAccessExpression(CSSyntaxKind.SimpleMemberAccessExpression, SyntaxFactory.IdentifierName("XNamespace"), SyntaxFactory.IdentifierName("Xmlns")); return(SyntaxFactory.BinaryExpression(CSSyntaxKind.AddExpression, xmlns, CommonConversions.Literal(fieldIdentifierName.Identifier.ValueText))); }
private static BinaryExpressionSyntax GetCompareTextCaseInsensitiveCompareOptions() { return(SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseOrExpression, SyntaxFactory.BinaryExpression(SyntaxKind.BitwiseOrExpression, ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreCase)), ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreKanaType))), ValidSyntaxFactory.MemberAccess(nameof(CompareOptions), nameof(CompareOptions.IgnoreWidth)) )); }
private static ExpressionSyntax Coalesce(ExpressionSyntax lhs, ExpressionSyntax emptyString) { return(SyntaxFactory.BinaryExpression(SyntaxKind.CoalesceExpression, lhs, emptyString)); }
/// <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[] GetStaticFields(List <FieldInfoMember> fields) { var result = new List <MemberDeclarationSyntax>(); // ReSharper disable once ReturnValueOfPureMethodIsNotUsed Expression <Action <Type> > getField = _ => _.GetField(string.Empty, BindingFlags.Default); 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 flags = SF.IdentifierName("System").Member("Reflection").Member("BindingFlags"); var publicFlag = flags.Member(BindingFlags.Public.ToString()); var nonPublicFlag = flags.Member(BindingFlags.NonPublic.ToString()); var instanceFlag = flags.Member(BindingFlags.Instance.ToString()); var bindingFlags = SF.ParenthesizedExpression( SF.BinaryExpression( SyntaxKind.BitwiseOrExpression, publicFlag, SF.BinaryExpression(SyntaxKind.BitwiseOrExpression, nonPublicFlag, instanceFlag))); // Add each field and initialize it. foreach (var field in fields) { var fieldInfo = getField.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()); }
public override SyntaxList <StatementSyntax> VisitForBlock(VBSyntax.ForBlockSyntax node) { var stmt = node.ForStatement; ExpressionSyntax startValue = (ExpressionSyntax)stmt.FromValue.Accept(_nodesVisitor); VariableDeclarationSyntax declaration = null; ExpressionSyntax id; if (stmt.ControlVariable is VBSyntax.VariableDeclaratorSyntax) { var v = (VBSyntax.VariableDeclaratorSyntax)stmt.ControlVariable; declaration = VisualBasicConverter.SplitVariableDeclarations(v, _nodesVisitor, _semanticModel).Values.Single(); declaration = declaration.WithVariables(SyntaxFactory.SingletonSeparatedList(declaration.Variables[0].WithInitializer(SyntaxFactory.EqualsValueClause(startValue)))); id = SyntaxFactory.IdentifierName(declaration.Variables[0].Identifier); } else { id = (ExpressionSyntax)stmt.ControlVariable.Accept(_nodesVisitor); var symbol = _semanticModel.GetSymbolInfo(stmt.ControlVariable).Symbol; if (!_semanticModel.LookupSymbols(node.FullSpan.Start, name: symbol.Name).Any()) { var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(symbol.Name), null, SyntaxFactory.EqualsValueClause(startValue)); declaration = SyntaxFactory.VariableDeclaration( SyntaxFactory.IdentifierName("var"), SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax)); } else { startValue = SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, id, startValue); } } var step = (ExpressionSyntax)stmt.StepClause?.StepValue.Accept(_nodesVisitor); PrefixUnaryExpressionSyntax value = step.SkipParens() as PrefixUnaryExpressionSyntax; ExpressionSyntax condition; if (value == null) { condition = SyntaxFactory.BinaryExpression(SyntaxKind.LessThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor)); } else { condition = SyntaxFactory.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, id, (ExpressionSyntax)stmt.ToValue.Accept(_nodesVisitor)); } if (step == null) { step = SyntaxFactory.PostfixUnaryExpression(SyntaxKind.PostIncrementExpression, id); } else { step = SyntaxFactory.AssignmentExpression(SyntaxKind.AddAssignmentExpression, id, step); } var block = SyntaxFactory.Block(node.Statements.SelectMany(s => s.Accept(CommentConvertingVisitor))); return(SingleStatement(SyntaxFactory.ForStatement( declaration, declaration != null ? SyntaxFactory.SeparatedList <ExpressionSyntax>() : SyntaxFactory.SingletonSeparatedList(startValue), condition, SyntaxFactory.SingletonSeparatedList(step), block.UnpackNonNestedBlock()))); }
public ExpressionBuilder Binary(SyntaxKind kind, ExpressionBuilder right) => new ExpressionBuilder(SF.BinaryExpression(kind, this.Build(), right.Build()));