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