/// <summary>
/// Returns syntax for dispatching <paramref name="event"/> to <paramref name="actor"/>.
/// </summary>
/// <param name="event">
/// The event.
/// </param>
/// <param name="actor">
/// The actor description.
/// </param>
/// <returns>
/// Syntax for dispatching <paramref name="event"/> to <paramref name="actor"/>.
/// </returns>
private static StatementSyntax GenerateActorBlock(
ExpressionSyntax @event,
ActorDescription actor)
{
var @var = SF.IdentifierName("var");
var grainType = actor.Type.GetTypeSyntax();
var getGrain =
SF.InvocationExpression(SF.IdentifierName("GrainFactory").Member("GetGrain", grainType))
.AddArgumentListArguments(SF.Argument(@event.Member("To").Member("Id")));
var grain = SF.VariableDeclarator("grain").WithInitializer(SF.EqualsValueClause(getGrain));
var grainDeclaration = SF.LocalDeclarationStatement(SF.VariableDeclaration(@var).AddVariables(grain));
var returnNull = SF.ReturnStatement(SF.LiteralExpression(SyntaxKind.NullLiteralExpression));
var defaultSection = SF.SwitchSection().AddLabels(SF.DefaultSwitchLabel()).AddStatements(returnNull);
var methodSwitch =
SF.SwitchStatement(@event.Member("Type"))
.AddSections(
actor.Methods.Values.Where(_ => _.Visible)
.Select(method => GetMethodSwitchCase(@event, method))
.ToArray())
.AddSections(defaultSection);
var methodDispatcher = SF.Block().AddStatements(grainDeclaration, methodSwitch);
return(methodDispatcher);
}
private async Task <EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntax(
VariableDeclaratorSyntax vbDeclarator, ModifiedIdentifierSyntax vbName,
VBSyntax.ExpressionSyntax vbInitValue,
ITypeSymbol declaredSymbolType,
ISymbol declaredSymbol, CSharpSyntaxNode initializerOrMethodDecl)
{
var csTypeSyntax = GetTypeSyntax(declaredSymbolType);
bool isField = vbDeclarator.Parent.IsKind(SyntaxKind.FieldDeclaration);
bool isConst = declaredSymbol is IFieldSymbol fieldSymbol && fieldSymbol.IsConst ||
declaredSymbol is ILocalSymbol localSymbol && localSymbol.IsConst;
EqualsValueClauseSyntax equalsValueClauseSyntax;
if (await GetInitializerFromNameAndType(declaredSymbolType, vbName, initializerOrMethodDecl) is ExpressionSyntax
adjustedInitializerExpr)
{
var convertedInitializer = vbInitValue != null
? TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr, isConst : isConst)
: adjustedInitializerExpr;
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer);
}
else if (isField || declaredSymbol != null && _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, vbName))
{
equalsValueClauseSyntax = null;
}
else
{
// VB initializes variables to their default
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax));
}
return(equalsValueClauseSyntax);
}
private ClassDeclarationSyntax GetClassForConstLocatorInInfo(WebLocatorInfo locatorInfo)
{
var infoMembers = new List <MemberDeclarationSyntax>();
var infoMembersList = new List <(string type, string fName, ExpressionSyntax expr)>
{
(nameof(WebLocatorType), nameof(locatorInfo.LocatorType), GetESForValue(locatorInfo.LocatorType)),
("string", nameof(locatorInfo.LocatorValue), GetESForValue(locatorInfo.LocatorValue)),
("bool", nameof(locatorInfo.IsRelative), GetESForValue(locatorInfo.IsRelative))
};
foreach (var infoMemberItem in infoMembersList)
{
var fd = SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName(infoMemberItem.type))
.AddVariables(SF.VariableDeclarator(SF.Identifier(infoMemberItem.fName))
.WithInitializer(SF.EqualsValueClause(infoMemberItem.expr))
)
)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.ConstKeyword));
infoMembers.Add(fd);
}
var infoCD = SF.ClassDeclaration(LocatorStaticClassName)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddMembers(infoMembers.ToArray());
return(infoCD);
}
/*
* public static T Or<T>(this Option<T> thisOption, T or)
* {
* T v;
*
* thisOption.
*
* return v;
* }
*/
public static FieldDeclarationSyntax Field(string fieldName, string type, Optional <ExpressionSyntax> assignment, params SyntaxKind[] modifiers)
{
//var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" );
//var newClass = SF.ParseExpression( $"new {m_class.Identifier}()" );
var declarator = SF.VariableDeclarator(fieldName);
if (assignment.HasValue)
{
declarator = declarator.WithInitializer(SF.EqualsValueClause(assignment.Value));
}
var decl = SF.VariableDeclaration(SF.IdentifierName(type), SF.SingletonSeparatedList(declarator));
var field = SF.FieldDeclaration(decl);
if (modifiers.Length > 0)
{
var stl = new SyntaxTokenList(modifiers.Select(mod => SF.Token(mod)));
field = field.WithModifiers(stl);
}
return(field);
}
private static MethodDeclarationSyntax MakeWithMethod(
TypeDeclarationSyntax type, IEnumerable <Field> fields, MethodDeclarationSyntax maybePreviousWithMethod)
{
var fieldsList = fields.ToList();
var withMethodParameters = SF.ParameterList(
SF.SeparatedList(
fieldsList.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)
)
)
.WithAttributeLists(field.Attributes)
)
)
);
var withMethodBodyStatements = fieldsList.Select(
field => SF.Argument(
SF.BinaryExpression(
SyntaxKind.CoalesceExpression, SF.IdentifierName(field.Name),
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name)
)
)
)
);
var previousAttributes = maybePreviousWithMethod?.AttributeLists ?? new SyntaxList <AttributeListSyntax>();
var typeSyntax = TypeSyntaxFactory.GetTypeSyntax(
type.Identifier.Text, type.TypeParameterList?.Parameters.Select(x => x.Identifier.Text).ToArray()
);
var res = SF.MethodDeclaration(typeSyntax, "With")
.WithAttributeLists(previousAttributes)
.WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) }))
.WithParameterList(withMethodParameters)
.WithBody(
SF.Block(
SF.ReturnStatement(
SF.ObjectCreationExpression(
typeSyntax, SF.ArgumentList(SF.SeparatedList(withMethodBodyStatements)), null
)
)
)
);
res = fieldsList.Any(x => x.StructuredTrivia != null) ? res.WithLeadingTrivia(
MakeXmlDocComments(maybePreviousWithMethod, fieldsList, Constants.DefaultModifierSummary)
) :
maybePreviousWithMethod?.HasLeadingTrivia ?? false?
res.WithLeadingTrivia(maybePreviousWithMethod.GetLeadingTrivia()) : res;
return(res);
}
private MemberDeclarationSyntax TypedMockProviderField()
{
return(F.FieldDeclaration(F.VariableDeclaration(TypesForSymbols.TypedMockProvider()).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(MockProviderName))
.WithInitializer(F.EqualsValueClause(F.ObjectCreationExpression(TypesForSymbols.TypedMockProvider())
.WithArgumentList(F.ArgumentList())))))
).WithModifiers(F.TokenList(F.Token(SyntaxKind.PrivateKeyword), F.Token(SyntaxKind.ReadOnlyKeyword))));
}
/// <summary>
/// Returns syntax for the deserializer method.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the deserializer method.</returns>
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields)
{
Expression <Action> deserializeInner =
() => SerializationManager.DeserializeInner(default(Type), default(IDeserializationContext));
var contextParameter = SF.IdentifierName("context");
var resultDeclaration =
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("result")
.WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type)))));
var resultVariable = SF.IdentifierName("result");
var body = new List <StatementSyntax> {
resultDeclaration
};
// Value types cannot be referenced, only copied, so there is no need to box & record instances of value types.
if (!type.GetTypeInfo().IsValueType)
{
// Record the result for cyclic deserialization.
Expression <Action <IDeserializationContext> > recordObject = ctx => ctx.RecordObject(default(object));
var currentSerializationContext = contextParameter;
body.Add(
SF.ExpressionStatement(
recordObject.Invoke(currentSerializationContext)
.AddArgumentListArguments(SF.Argument(resultVariable))));
}
// Deserialize all fields.
foreach (var field in fields)
{
var deserialized =
deserializeInner.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(field.Type)),
SF.Argument(contextParameter));
body.Add(
SF.ExpressionStatement(
field.GetSetter(
resultVariable,
SF.CastExpression(field.Type, deserialized))));
}
body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), resultVariable)));
return
(SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()),
SF.Parameter(SF.Identifier("context")).WithType(typeof(IDeserializationContext).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax()))));
}
public FieldDeclarationSyntax ToFieldDeclaration()
{
if (canonicalName.value != name.name.value)
{
Console.WriteLine($"Warning!!! '{canonicalName.value}' != '{name.name.value}';");
}
if (annotations.Count != 0)
{
Console.WriteLine($"Warning!!! Annotations!;");
}
var declaratorSyntax = SF.VariableDeclarator(SF.Identifier(name.name.value));
if (initializer.TryGetValue(out var initializerExpression))
{
declaratorSyntax = declaratorSyntax.WithInitializer(
// todo: I think this might not work ... a lot!
SF.EqualsValueClause(initializerExpression.ToLiteralExpressionSyntax()));
}
var fieldDeclaration = SF.FieldDeclaration(
SF.VariableDeclaration(type.ToTypeSyntax())
.WithVariables(SF.SingletonSeparatedList <VariableDeclaratorSyntax>(declaratorSyntax)));
if (flags.HasFlag(Flag.isConst))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ConstKeyword)));
}
if (flags.HasFlag(Flag.isFinal))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
if (flags.HasFlag(Flag.isStatic))
{
fieldDeclaration = fieldDeclaration.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.StaticKeyword)));
}
if (flags.HasFlag(Flag.isCovariant))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.isGenericCovariantImpl))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitSetter))
{
throw new NotImplementedException();
}
if (flags.HasFlag(Flag.hasImplicitGetter))
{
throw new NotImplementedException();
}
return(fieldDeclaration);
}
private static MemberDeclarationSyntax GenerateDeserializerMethod(Type type, List <FieldInfoMember> fields)
{
Expression <Action> deserializeInner =
() => SerializationManager.DeserializeInner(default(Type), default(BinaryTokenStreamReader));
var streamParameter = SF.IdentifierName("stream");
var resultDeclaration =
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("result")
.WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type)))));
var resultVariable = SF.IdentifierName("result");
var boxedResultVariable = resultVariable;
var body = new List <StatementSyntax> {
resultDeclaration
};
if (type.IsValueType)
{
// For value types, we need to box the result for reflection-based setters to work.
body.Add(SF.LocalDeclarationStatement(
SF.VariableDeclaration(typeof(object).GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("boxedResult").WithInitializer(SF.EqualsValueClause(resultVariable)))));
boxedResultVariable = SF.IdentifierName("boxedResult");
}
// Deserialize all fields.
foreach (var field in fields)
{
var deserialized =
deserializeInner.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(field.Type)),
SF.Argument(streamParameter));
body.Add(
SF.ExpressionStatement(
field.GetSetter(
resultVariable,
SF.CastExpression(field.Type, deserialized),
boxedResultVariable)));
}
body.Add(SF.ReturnStatement(SF.CastExpression(type.GetTypeSyntax(), boxedResultVariable)));
return
(SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "Deserializer")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()),
SF.Parameter(SF.Identifier("stream")).WithType(typeof(BinaryTokenStreamReader).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(SF.Attribute(typeof(DeserializerMethodAttribute).GetNameSyntax()))));
}
private SyntaxTree CreateSyntaxTree()
{
var compilationUnit = SF
.CompilationUnit()
.AddUsings
(
SF.UsingDirective
(SF.ParseName("System"))
);
var ns = SF
.NamespaceDeclaration(SF.IdentifierName("SynTreeFred"));
var cls = SF
.ClassDeclaration("Henry")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword));
// How to define base class and interfaces, with/without generics
//
//cls = cls.AddBaseListTypes(
// SF.SimpleBaseType(SF.ParseTypeName("Object")),
// SF.SimpleBaseType(SF.ParseTypeName("IEnumerable<string>")));
var inti = SF
.VariableDeclaration(SF.ParseTypeName("int"))
.AddVariables
(
SF.VariableDeclarator
(
SF.Identifier("i"),
null,
SF.EqualsValueClause
(
SF.LiteralExpression
(
SyntaxKind.NumericLiteralExpression,
SF.Literal(12)
)
)
)
);
var field = SF.FieldDeclaration(inti)
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword));
var syntax = SF.ParseStatement("return ++i;");
var methodDeclaration = SF
.MethodDeclaration(SF.ParseTypeName("int"), "GetNextInt")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword))
.WithBody(SF.Block(syntax));
cls = cls.AddMembers(field, methodDeclaration);
ns = ns.AddMembers(cls);
compilationUnit = compilationUnit.AddMembers(ns);
return(compilationUnit.SyntaxTree);
}
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(
VariableDeclaratorSyntax declarator, bool preferExplicitType = false)
{
var rawType = ConvertDeclaratorType(declarator, preferExplicitType);
var initializer = ConvertInitializer(declarator);
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
var method = declarator.Ancestors().OfType <MethodBlockBaseSyntax>().SingleOrDefault();
DataFlowAnalysis dataFlow = null;
if (method != null)
{
dataFlow = _semanticModel.AnalyzeDataFlow(method.Statements.First(), method.Statements.Last());
}
foreach (var name in declarator.Names)
{
var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer);
bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration);
EqualsValueClauseSyntax equalsValueClauseSyntax;
if (adjustedInitializer != null)
{
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(adjustedInitializer);
}
else
{
Func <ISymbol, bool> equalsId = s => s.Name.Equals(name.Identifier.ValueText, StringComparison.OrdinalIgnoreCase);
bool alwaysAssigned = dataFlow != null && dataFlow.AlwaysAssigned.Any(equalsId);
bool neverRead = dataFlow != null && !dataFlow.ReadInside.Any(equalsId) && !dataFlow.ReadOutside.Any(equalsId);
if (isField || alwaysAssigned || neverRead)
{
equalsValueClauseSyntax = null;
}
else
{
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(type));
}
}
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
string k = type.ToString();
if (newDecls.TryGetValue(k, out var decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
private static VariableDeclarationSyntax CreateVariableDeclaration(string variableName,
ExpressionSyntax variableValue)
{
var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(SyntaxFactory.Identifier(variableName), null,
SyntaxFactory.EqualsValueClause(variableValue));
var declaration = SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax));
return(declaration);
}
private async Task <EqualsValueClauseSyntax> ConvertEqualsValueClauseSyntaxAsync(
VariableDeclaratorSyntax vbDeclarator, VBSyntax.ModifiedIdentifierSyntax vbName,
VBSyntax.ExpressionSyntax vbInitValue,
ITypeSymbol declaredSymbolType,
ISymbol declaredSymbol, CSharpSyntaxNode initializerOrMethodDecl)
{
var csTypeSyntax = GetTypeSyntax(declaredSymbolType);
bool isField = vbDeclarator.Parent.IsKind(SyntaxKind.FieldDeclaration);
bool declaredConst = declaredSymbol is IFieldSymbol fieldSymbol && fieldSymbol.IsConst ||
declaredSymbol is ILocalSymbol localSymbol && localSymbol.IsConst;
EqualsValueClauseSyntax equalsValueClauseSyntax;
if (await GetInitializerFromNameAndTypeAsync(declaredSymbolType, vbName, initializerOrMethodDecl) is ExpressionSyntax
adjustedInitializerExpr)
{
var convertedInitializer = vbInitValue != null
? TypeConversionAnalyzer.AddExplicitConversion(vbInitValue, adjustedInitializerExpr, isConst : declaredConst)
: adjustedInitializerExpr;
if (isField && !declaredSymbol.IsStatic && !_semanticModel.IsDefinitelyStatic(vbName, vbInitValue))
{
if (_typeContext.Initializers.ShouldAddTypeWideInitToThisPart)
{
var lhs = SyntaxFactory.IdentifierName(ConvertIdentifier(vbName.Identifier, sourceTriviaMapKind: SourceTriviaMapKind.None));
_typeContext.Initializers.AdditionalInstanceInitializers.Add((lhs, CSSyntaxKind.SimpleAssignmentExpression, adjustedInitializerExpr));
equalsValueClauseSyntax = null;
}
else
{
var returnBlock = SyntaxFactory.Block(SyntaxFactory.ReturnStatement(adjustedInitializerExpr));
_typeContext.HoistedState.Hoist <HoistedParameterlessFunction>(new HoistedParameterlessFunction(GetInitialValueFunctionName(vbName), csTypeSyntax, returnBlock));
equalsValueClauseSyntax = null;
}
}
else
{
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer);
}
}
else if (isField || declaredSymbol != null && _semanticModel.IsDefinitelyAssignedBeforeRead(declaredSymbol, vbName))
{
equalsValueClauseSyntax = null;
}
else
{
// VB initializes variables to their default
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(csTypeSyntax));
}
return(equalsValueClauseSyntax);
}
private static ClassDeclarationSyntax AddStubContainerField(ClassDeclarationSyntax classDclr, string stubName)
{
classDclr = classDclr.AddMembers(
SF.FieldDeclaration(
SF.VariableDeclaration(SF.ParseTypeName($"StubContainer<{stubName}>"),
SF.SeparatedList(new[]
{
SF.VariableDeclarator(SF.Identifier("_stubs"), null,
SF.EqualsValueClause(SF.ParseExpression($"new StubContainer<{stubName}>()")))
})))
.AddModifiers(SF.Token(SyntaxKind.PrivateKeyword), SF.Token(SyntaxKind.ReadOnlyKeyword)));
return(classDclr);
}
/// <summary>
/// Yields "bool name;"
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
internal static LocalDeclarationStatementSyntax DeclareIntVariable(string name)
{
return
(SF.LocalDeclarationStatement(
SF.VariableDeclaration(
SF.PredefinedType(SF.Token(SyntaxKind.IntKeyword)),
new SeparatedSyntaxList <VariableDeclaratorSyntax>().Add(
SF.VariableDeclarator(SF.Identifier(name), default(BracketedArgumentListSyntax),
SF.EqualsValueClause(SF.ParseExpression("0")))
)
)
));
}
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(
VariableDeclaratorSyntax declarator, bool preferExplicitType = false)
{
var rawType = ConvertDeclaratorType(declarator, preferExplicitType);
var initializer = ConvertInitializer(declarator);
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer);
bool isField = declarator.Parent.IsKind(SyntaxKind.FieldDeclaration);
EqualsValueClauseSyntax equalsValueClauseSyntax;
if (adjustedInitializer != null)
{
var vbInitializer = declarator.Initializer?.Value;
// Explicit conversions are never needed for AsClause, since the type is inferred from the RHS
var convertedInitializer = vbInitializer == null ? adjustedInitializer : TypeConversionAnalyzer.AddExplicitConversion(vbInitializer, adjustedInitializer);
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(convertedInitializer);
}
else if (isField || _semanticModel.IsDefinitelyAssignedBeforeRead(declarator, name))
{
equalsValueClauseSyntax = null;
}
else
{
// VB initializes variables to their default
equalsValueClauseSyntax = SyntaxFactory.EqualsValueClause(SyntaxFactory.DefaultExpression(type));
}
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
string k = type.ToString();
if (newDecls.TryGetValue(k, out var decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
private static MemberDeclarationSyntax GenerateSerializerMethod(Type type, List <FieldInfoMember> fields)
{
Expression <Action> serializeInner =
() =>
SerializationManager.SerializeInner(default(object), default(ISerializationContext), default(Type));
var contextParameter = SF.IdentifierName("context");
var body = new List <StatementSyntax>
{
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("input")
.WithInitializer(
SF.EqualsValueClause(
SF.CastExpression(type.GetTypeSyntax(), SF.IdentifierName("untypedInput"))))))
};
var inputExpression = SF.IdentifierName("input");
// Serialize all members.
foreach (var field in fields)
{
body.Add(
SF.ExpressionStatement(
serializeInner.Invoke()
.AddArgumentListArguments(
SF.Argument(field.GetGetter(inputExpression, forceAvoidCopy: true)),
SF.Argument(contextParameter),
SF.Argument(SF.TypeOfExpression(field.FieldInfo.FieldType.GetTypeSyntax())))));
}
return
(SF.MethodDeclaration(typeof(void).GetTypeSyntax(), "Serializer")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("untypedInput")).WithType(typeof(object).GetTypeSyntax()),
SF.Parameter(SF.Identifier("context")).WithType(typeof(ISerializationContext).GetTypeSyntax()),
SF.Parameter(SF.Identifier("expected")).WithType(typeof(Type).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList()
.AddAttributes(SF.Attribute(typeof(SerializerMethodAttribute).GetNameSyntax()))));
}
public override SyntaxList <StatementSyntax> VisitWithBlock(VBSyntax.WithBlockSyntax node)
{
var withExpression = (ExpressionSyntax)node.WithStatement.Expression.Accept(nodesVisitor);
withBlockTempVariableNames.Push(GetUniqueVariableNameInScope(node, "withBlock"));
try {
var variableDeclaratorSyntax = SyntaxFactory.VariableDeclarator(
SyntaxFactory.Identifier(withBlockTempVariableNames.Peek()), null,
SyntaxFactory.EqualsValueClause(withExpression));
var declaration = SyntaxFactory.LocalDeclarationStatement(SyntaxFactory.VariableDeclaration(
SyntaxFactory.IdentifierName("var"),
SyntaxFactory.SingletonSeparatedList(variableDeclaratorSyntax)));
var statements = node.Statements.SelectMany(s => s.Accept(this));
return(SingleStatement(SyntaxFactory.Block(new[] { declaration }.Concat(statements).ToArray())));
} finally {
withBlockTempVariableNames.Pop();
}
}
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)))));
}
public static PropertyDeclarationSyntax GenProperty(string type, string name, bool setter, string initializer = null)
{
var accessors = setter
? new[] { SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)),
SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) }
: new[] { SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken)) };
return(SF.PropertyDeclaration(
attributeLists: SF.List <AttributeListSyntax>(),
modifiers: SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)),
type: SF.ParseTypeName(type),
explicitInterfaceSpecifier: null,
identifier: SF.Identifier(name),
accessorList: SF.AccessorList(SF.List(accessors)),
expressionBody: null,
initializer: initializer == null ? null : SF.EqualsValueClause(SF.ParseExpression(initializer)),
semicolonToken: initializer == null ? SF.Token(SyntaxKind.None) : SF.Token(SyntaxKind.SemicolonToken)));
}
private ClassDeclarationSyntax AddConstructor(INamedTypeSymbol interfaceType, ClassDeclarationSyntax classDclr, SimpleStubsConfig config)
{
string ctorName = NamingUtils.GetStubName(interfaceType.Name);
string defaultMockBehavior = GetValidMockBehaviorEnumValue(config.DefaultMockBehavior);
var ctorParameter =
SF.Parameter(SF.Identifier("mockBehavior"))
.WithType(SF.ParseTypeName("MockBehavior"))
.WithDefault(SF.EqualsValueClause(SF.ParseExpression($"MockBehavior.{defaultMockBehavior}")));
classDclr = classDclr.AddMembers(SF.ConstructorDeclaration(ctorName)
.WithModifiers(SF.TokenList(SF.Token(SyntaxKind.PublicKeyword)))
.WithParameterList(SF.ParameterList().AddParameters(ctorParameter))
.WithBody(SF.Block().AddStatements(SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.IdentifierName("MockBehavior"),
SF.IdentifierName("mockBehavior")))
)));
return(classDclr);
}
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());
}
private SyntaxList <MemberDeclarationSyntax> CreateDefault()
{
var list = new SyntaxList <MemberDeclarationSyntax>();
//var st = SF.ParseStatement( $"static public readonly {m_class.Identifier} def = new {m_class.Identifier};" );
var newClass = SF.ParseExpression($"new {SU.ClassNameWithGenerics(m_class)}()");
var declarator = SF.VariableDeclarator("def")
.WithInitializer(SF.EqualsValueClause(newClass));
var decl = SF.VariableDeclaration(SF.IdentifierName(SU.ClassNameWithGenerics(m_class)), SF.SingletonSeparatedList(declarator));
var keywords = SyntaxTokenList.Create(SF.Token(SyntaxKind.PublicKeyword))
.Add(SF.Token(SyntaxKind.StaticKeyword))
.Add(SF.Token(SyntaxKind.ReadOnlyKeyword));
var field = SF.FieldDeclaration(decl)
.WithModifiers(keywords);
list = list.Add(field);
return(list);
}
/// <summary>
/// Generates a <see cref="GenericMethodInvoker"/> field for the provided generic method.
/// </summary>
/// <param name="method">The method.</param>
/// <returns>The generated field.</returns>
private static MemberDeclarationSyntax GenerateGenericInvokerField(MethodInfo method)
{
var fieldInfoVariable =
SF.VariableDeclarator(GetGenericMethodInvokerFieldName(method))
.WithInitializer(
SF.EqualsValueClause(
SF.ObjectCreationExpression(typeof(GenericMethodInvoker).GetTypeSyntax())
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(method.DeclaringType.GetTypeSyntax())),
SF.Argument(method.Name.GetLiteralExpression()),
SF.Argument(
SF.LiteralExpression(
SyntaxKind.NumericLiteralExpression,
SF.Literal(method.GetGenericArguments().Length))))));
return
(SF.FieldDeclaration(
SF.VariableDeclaration(typeof(GenericMethodInvoker).GetTypeSyntax()).AddVariables(fieldInfoVariable))
.AddModifiers(
SF.Token(SyntaxKind.PrivateKeyword),
SF.Token(SyntaxKind.StaticKeyword),
SF.Token(SyntaxKind.ReadOnlyKeyword)));
}
/// <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 the deep copier method.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="fields">The fields.</param>
/// <returns>Syntax for the deep copier method.</returns>
private static MemberDeclarationSyntax GenerateDeepCopierMethod(Type type, List <FieldInfoMember> fields)
{
var originalVariable = SF.IdentifierName("original");
var inputVariable = SF.IdentifierName("input");
var resultVariable = SF.IdentifierName("result");
var body = new List <StatementSyntax>();
if (type.GetCustomAttribute <ImmutableAttribute>() != null)
{
// Immutable types do not require copying.
body.Add(SF.ReturnStatement(originalVariable));
}
else
{
body.Add(
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("input")
.WithInitializer(
SF.EqualsValueClause(
SF.ParenthesizedExpression(
SF.CastExpression(type.GetTypeSyntax(), originalVariable)))))));
body.Add(
SF.LocalDeclarationStatement(
SF.VariableDeclaration(type.GetTypeSyntax())
.AddVariables(
SF.VariableDeclarator("result")
.WithInitializer(SF.EqualsValueClause(GetObjectCreationExpressionSyntax(type))))));
// Copy all members from the input to the result.
foreach (var field in fields)
{
body.Add(SF.ExpressionStatement(field.GetSetter(resultVariable, field.GetGetter(inputVariable))));
}
// Record this serialization.
Expression <Action> recordObject =
() => SerializationContext.Current.RecordObject(default(object), default(object));
var currentSerializationContext =
SyntaxFactory.AliasQualifiedName(
SF.IdentifierName(SF.Token(SyntaxKind.GlobalKeyword)),
SF.IdentifierName("Orleans"))
.Qualify("Serialization")
.Qualify("SerializationContext")
.Qualify("Current");
body.Add(
SF.ExpressionStatement(
recordObject.Invoke(currentSerializationContext)
.AddArgumentListArguments(SF.Argument(originalVariable), SF.Argument(resultVariable))));
body.Add(SF.ReturnStatement(resultVariable));
}
return
(SF.MethodDeclaration(typeof(object).GetTypeSyntax(), "DeepCopier")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("original")).WithType(typeof(object).GetTypeSyntax()))
.AddBodyStatements(body.ToArray())
.AddAttributeLists(
SF.AttributeList().AddAttributes(SF.Attribute(typeof(CopierMethodAttribute).GetNameSyntax()))));
}
protected MemberDeclarationSyntax ExplicitInterfaceMember()
{
var baseReturnType = Symbol.ReturnsVoid
? F.PredefinedType(F.Token(SyntaxKind.VoidKeyword))
: TypesForSymbols.ParseTypeName(Symbol.ReturnType, Symbol.ReturnTypeIsNullableOrOblivious());
var returnType = baseReturnType;
if (Symbol.ReturnsByRef)
{
returnType = F.RefType(returnType);
}
else if (Symbol.ReturnsByRefReadonly)
{
returnType = F.RefType(returnType).WithReadOnlyKeyword(F.Token(SyntaxKind.ReadOnlyKeyword));
}
var mockedMethod = ExplicitInterfaceMemberMethodDeclaration(returnType);
var memberMockInstance = ExplicitInterfaceMemberMemberMockInstance();
ExpressionSyntax invocation = F.InvocationExpression(
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
memberMockInstance, F.IdentifierName("Call")))
.WithExpressionsAsArgumentList(ParametersType.BuildArgumentListWithOriginalNames());
// look at the return parameters. If we don't have any we can just make the call.
// if we only have one and that's the return value, we can just return it.
if (ReturnValuesType.Count == 0 ||
ReturnValuesType.Count == 1 && ReturnValuesType[0].IsReturnValue)
{
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
invocation = TypesForSymbols.WrapByRef(invocation, baseReturnType);
}
mockedMethod = mockedMethod.WithExpressionBody(F.ArrowExpressionClause(invocation))
.WithSemicolonToken(F.Token(SyntaxKind.SemicolonToken));
}
// if we only have one and that's not a return value, we can just assign it to the out or ref parameter it corresponds to.
else if (ReturnValuesType.Count == 1)
{
mockedMethod = mockedMethod.WithBody(F.Block(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(ReturnValuesType[0].OriginalName), invocation))));
}
else
{
// if we have more than one, put it in a temporary variable. (consider name clashes with method parameter names)
var x = new Uniquifier(Symbol.Parameters.Select(m => m.Name));
string tmp = x.GetUniqueName("tmp");
var statements = new List <StatementSyntax>
{
F.LocalDeclarationStatement(F.VariableDeclaration(F.IdentifierName("var")).WithVariables(
F.SingletonSeparatedList(F.VariableDeclarator(F.Identifier(tmp)).WithInitializer(F.EqualsValueClause(invocation)))))
};
// then for any out or ref parameters, set their values from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => !a.IsReturnValue))
{
statements.Add(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(rv.OriginalName),
F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName)))));
}
// finally, if there is a 'proper' return type, return the corresponding value from the temporary variable.
foreach (var rv in ReturnValuesType.Where(a => a.IsReturnValue))
{
ExpressionSyntax memberAccess = F.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression, F.IdentifierName(tmp),
F.IdentifierName(rv.TupleSafeName));
if (Symbol.ReturnsByRef || Symbol.ReturnsByRefReadonly)
{
memberAccess = TypesForSymbols.WrapByRef(memberAccess, baseReturnType);
}
statements.Add(F.ReturnStatement(memberAccess));
}
mockedMethod = mockedMethod.WithBody(F.Block(statements));
}
return(mockedMethod);
}
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 })));
}
public Dictionary <string, VariableDeclarationSyntax> SplitVariableDeclarations(
VariableDeclaratorSyntax declarator, bool preferExplicitType = false)
{
var rawType = ConvertDeclaratorType(declarator, preferExplicitType);
var initializer = ConvertInitializer(declarator);
var newDecls = new Dictionary <string, VariableDeclarationSyntax>();
foreach (var name in declarator.Names)
{
var(type, adjustedInitializer) = AdjustFromName(rawType, name, initializer);
var equalsValueClauseSyntax = adjustedInitializer == null ? null : SyntaxFactory.EqualsValueClause(adjustedInitializer);
var v = SyntaxFactory.VariableDeclarator(ConvertIdentifier(name.Identifier), null, equalsValueClauseSyntax);
string k = type.ToString();
if (newDecls.TryGetValue(k, out var decl))
{
newDecls[k] = decl.AddVariables(v);
}
else
{
newDecls[k] = SyntaxFactory.VariableDeclaration(type, SyntaxFactory.SingletonSeparatedList(v));
}
}
return(newDecls);
}
/// <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));
}
