private static ExpressionStatementSyntax CreateArrayCopyWithStartingPoints(
IdentifierNameSyntax sourceExpression, ExpressionSyntax sourceStart,
ExpressionSyntax targetExpression, ExpressionSyntax targetStart, ExpressionSyntax length)
{
var copyArgList = ExpressionSyntaxExtensions.CreateArgList(sourceExpression, sourceStart, targetExpression, targetStart, length);
var arrayCopy = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Array.Copy"), copyArgList);
return(SyntaxFactory.ExpressionStatement(arrayCopy));
}
/// <summary>
/// Yields "variable = lhs==rhs;"
/// </summary>
/// <param name="variable"></param>
/// <param name="value"></param>
/// <returns></returns>
internal static ExpressionStatementSyntax AssignValueEqualsValue(string variable, string lhs, string rhs)
{
return
(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SF.ParseExpression(variable),
SF.ParseExpression($"{lhs}=={rhs}")
)
));
}
/// <summary>
/// Returns syntax for the constructor.
/// </summary>
/// <param name="className">The name of the class.</param>
/// <returns>Syntax for the constructor.</returns>
private static ConstructorDeclarationSyntax GenerateConstructor(string className)
{
return
(SF.ConstructorDeclaration(className)
.AddModifiers(SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters()
.AddBodyStatements(
SF.ExpressionStatement(
SF.InvocationExpression(SF.IdentifierName("Register")).AddArgumentListArguments())));
}
private static ExpressionStatementSyntax CreateArrayCopyWithMinOfLengths(
IdentifierNameSyntax sourceExpression, ExpressionSyntax sourceLength,
ExpressionSyntax targetExpression, ExpressionSyntax targetLength)
{
var minLength = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Math.Min"), ExpressionSyntaxExtensions.CreateArgList(targetLength, sourceLength));
var copyArgList = ExpressionSyntaxExtensions.CreateArgList(sourceExpression, targetExpression, minLength);
var arrayCopy = SyntaxFactory.InvocationExpression(SyntaxFactory.ParseExpression("Array.Copy"), copyArgList);
return(SyntaxFactory.ExpressionStatement(arrayCopy));
}
/// <summary>
/// Yields "variable = false;"
/// </summary>
/// <param name="variable"></param>
/// <returns></returns>
internal static ExpressionStatementSyntax AssignFalse(string variable)
{
return
(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SF.ParseExpression(variable),
SF.ParseExpression($"false")
)
));
}
////for (int i = 0; i<length; i++)
////{
//// // inside-for
////}
////// next
////int i = 0;
////if (i<length)
////{
//// // inside-for
//// i++;
//// if (i<length)
//// {
//// // inside-for
//// i++;
//// }
////}
////// next
public override SyntaxNode VisitForStatement(ForStatementSyntax node)
{
var incrementator = node.Incrementors.Single();
var forStatementsBlock = SF.Block(JoinStatements(node.Statement, SF.ExpressionStatement(incrementator)));
var ifStatement = MakeIfStatement(LoopIterations, forStatementsBlock, SF.IfStatement(node.Condition, forStatementsBlock));
return(SF.Block(SF.LocalDeclarationStatement(node.Declaration), ifStatement));
}
/// <summary>
/// Yields "variable = value==0;"
/// </summary>
/// <param name="variable"></param>
/// <param name="value"></param>
/// <returns></returns>
internal static ExpressionStatementSyntax AssignValueEqualsZero(string variable, string value)
{
return
(SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SF.ParseExpression(variable),
SF.ParseExpression($"{value}==0")
)
));
}
public static StatementSyntax MakeStatePopWriteStatement()
{
return(SF.ExpressionStatement(SF.InvocationExpression(
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName("_this"),
SF.IdentifierName("Write")),
SF.ArgumentList(SF.SingletonSeparatedList <ArgumentSyntax>(SF.Argument(MakeStatePopExpression()))
)
)));
}
public override void Exit()
{
var setStatement = SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
VariableHelper.MakeStateVariableExpression(_variableName),
_valueExpression
)
);
_exitHandler(setStatement);
}
public static StatementSyntax MakeModelAssignmentStatement()
{
return(SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.BaseExpression(),
SF.IdentifierName("Model")
),
SF.IdentifierName("model")
)));
}
public override SyntaxList <StatementSyntax> VisitEraseStatement(VBSyntax.EraseStatementSyntax node)
{
var eraseStatements = node.Expressions.Select <VBSyntax.ExpressionSyntax, StatementSyntax>(arrayExpression => {
var lhs = arrayExpression.Accept(_nodesVisitor);
var rhs = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression);
var assignmentExpressionSyntax =
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, (ExpressionSyntax)lhs,
rhs);
return(SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax));
});
return(SyntaxFactory.List(eraseStatements));
}
/// <summary>
/// Generates syntax to invoke a method on a grain.
/// </summary>
/// <param name="grainType">
/// The grain type.
/// </param>
/// <param name="grain">
/// The grain instance expression.
/// </param>
/// <param name="method">
/// The method.
/// </param>
/// <param name="arguments">
/// The arguments expression.
/// </param>
/// <returns>
/// Syntax to invoke a method on a grain.
/// </returns>
private static StatementSyntax[] GenerateInvokeForMethod(
Type grainType,
IdentifierNameSyntax grain,
MethodInfo method,
ExpressionSyntax arguments)
{
var castGrain = SF.ParenthesizedExpression(SF.CastExpression(grainType.GetTypeSyntax(), grain));
// Construct expressions to retrieve each of the method's parameters.
var parameters = new List <ExpressionSyntax>();
var methodParameters = method.GetParameters().ToList();
for (var i = 0; i < methodParameters.Count; i++)
{
var parameter = methodParameters[i];
var parameterType = parameter.ParameterType.GetTypeSyntax();
var indexArg = SF.Argument(SF.LiteralExpression(SyntaxKind.NumericLiteralExpression, SF.Literal(i)));
var arg = SF.CastExpression(
parameterType,
SF.ElementAccessExpression(arguments).AddArgumentListArguments(indexArg));
parameters.Add(arg);
}
// Invoke the method.
var grainMethodCall =
SF.InvocationExpression(castGrain.Member(method.Name))
.AddArgumentListArguments(parameters.Select(SF.Argument).ToArray());
// For void methods, invoke the method and return a completed task.
if (method.ReturnType == typeof(void))
{
var completed = (Expression <Func <Task <object> > >)(() => TaskUtility.Completed());
return(new StatementSyntax[]
{
SF.ExpressionStatement(grainMethodCall), SF.ReturnStatement(completed.Invoke())
});
}
// For methods which return the expected type, Task<object>, simply return that.
if (method.ReturnType == typeof(Task <object>))
{
return(new StatementSyntax[] { SF.ReturnStatement(grainMethodCall) });
}
// The invoke method expects a Task<object>, so we need to upcast the returned value.
// For methods which do not return a value, the Box extension method returns a meaningless value.
return(new StatementSyntax[]
{
SF.ReturnStatement(SF.InvocationExpression(grainMethodCall.Member((Task _) => _.Box())))
});
}
private async Task <Document> AddSecureFlags(Document document,
Diagnostic diagnostic,
CancellationToken cancellationToken,
string[] propertyNames)
{
var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
var variableDeclarator = FindParentNode(root.FindToken(diagnostic.Location.SourceSpan.Start).Parent);
if (variableDeclarator == null)
{
return(document); //Abort!
}
if (!(variableDeclarator.Parent is VariableDeclarationSyntax variableDeclaration))
{
return(document); //Abort!
}
if (!(variableDeclaration.Parent is LocalDeclarationStatementSyntax parentDeclaration))
{
return(document); //Abort!
}
var identifierCookie = variableDeclaration.Variables[0];
//Building the nodes model
var nodes = new List <SyntaxNode>();
foreach (var property in propertyNames)
{
var newAssignment = SF.ExpressionStatement(
SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
SF.IdentifierName(identifierCookie.Identifier),
SF.IdentifierName(property)),
SF.LiteralExpression(SyntaxKind.TrueLiteralExpression)
))
.WithLeadingTrivia(CodeFixUtil.KeepLastLine(parentDeclaration.GetLeadingTrivia()));
/*
* .WithLeadingTrivia(parentDeclaration.GetLeadingTrivia()
* .Insert(0, SF.ElasticEndOfLine(Environment.NewLine))
* );*/
nodes.Add(newAssignment);
}
//Inserting the nodes
var newRoot = root.InsertNodesAfter(parentDeclaration, nodes);
return(document.WithSyntaxRoot(newRoot));
}
protected ExpressionStatementSyntax InitialisationStatement(TypeSyntax mockPropertyType)
{
return(F.ExpressionStatement(F.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
F.IdentifierName(MemberMockName),
F.ObjectCreationExpression(mockPropertyType)
.WithExpressionsAsArgumentList(
F.ThisExpression(),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(ClassSymbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(InterfaceSymbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(Symbol.Name)),
F.LiteralExpression(SyntaxKind.StringLiteralExpression, F.Literal(MemberMockName)),
StrictnessExpression()
))));
}
public override BlockSyntax GenerateMethodBody()
{
var whileStatement = new SyntaxList <StatementSyntax>()
.Add(SF.ParseStatement("if (!reader.TryGetByte(out var bsonType)) { return false; }"))
.Add(SF.ParseStatement("if (!reader.TryGetCStringAsSpan(out var bsonName)) { return false; } "))
.AddRange(OperationsList.CreateReadOperations(ClassSymbol, Members).Generate())
.Add(SF.ParseStatement(@$ "throw new ArgumentException($" "{ClassSymbol.Name}.TryParse with bson type number {{bsonType}} and name {{System.Text.Encoding.UTF8.GetString(bsonName)}}" ");"));
return(SF.Block(
SF.ExpressionStatement(SF.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, Basics.TryParseOutVariableIdentifier, Basics.ObjectCreationWitoutArgs(ClassSymbol))),
SF.ParseStatement("if (!reader.TryGetInt32(out var docLength)) { return false; }"),
SF.ParseStatement("var unreaded = reader.Remaining + sizeof(int);"),
SF.WhileStatement(
attributeLists: default,
protected override BlockSyntax GetBody()
{
if (Method.IsAbstract)
{
return(null);
}
if (Method.Returns == null)
{
return(SF.Block(SF.ExpressionStatement(CreateInvocationExpression())));
}
return(SF.Block(SF.ReturnStatement(CreateInvocationExpression())));
}
/// <summary>
/// Returns syntax for the generic serializer registration method for the provided type..
/// </summary>
/// <param name="type">The type which is supported by this serializer.</param>
/// <param name="serializerType">The type of the serializer.</param>
/// <returns>Syntax for the generic serializer registration method for the provided type..</returns>
private static MemberDeclarationSyntax GenerateMasterRegisterMethod(Type type, TypeSyntax serializerType)
{
Expression<Action> register = () => SerializationManager.Register(default(Type), default(Type));
return
SF.MethodDeclaration(typeof(void).GetTypeSyntax(), "Register")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters()
.AddBodyStatements(
SF.ExpressionStatement(
register.Invoke()
.AddArgumentListArguments(
SF.Argument(
SF.TypeOfExpression(type.GetTypeSyntax(includeGenericParameters: false))),
SF.Argument(SF.TypeOfExpression(serializerType)))));
}
private ExpressionStatementSyntax CreateNewArrayAssignment(VBSyntax.ExpressionSyntax vbArrayExpression,
ExpressionSyntax csArrayExpression, List <ExpressionSyntax> convertedBounds,
int nodeSpanStart)
{
var arrayRankSpecifierSyntax = SyntaxFactory.ArrayRankSpecifier(SyntaxFactory.SeparatedList(convertedBounds));
var convertedType = (IArrayTypeSymbol)_semanticModel.GetTypeInfo(vbArrayExpression).ConvertedType;
var typeSyntax = GetTypeSyntaxFromTypeSymbol(convertedType.ElementType, nodeSpanStart);
var arrayCreation =
SyntaxFactory.ArrayCreationExpression(SyntaxFactory.ArrayType(typeSyntax,
SyntaxFactory.SingletonList(arrayRankSpecifierSyntax)));
var assignmentExpressionSyntax =
SyntaxFactory.AssignmentExpression(SyntaxKind.SimpleAssignmentExpression, csArrayExpression, arrayCreation);
var newArrayAssignment = SyntaxFactory.ExpressionStatement(assignmentExpressionSyntax);
return(newArrayAssignment);
}
/// <summary>
/// Yields "sb.Append(argument)"
/// </summary>
/// <param name="argument"></param>
/// <returns></returns>
private static ExpressionStatementSyntax SbAppend(ArgumentSyntax argument, bool encoded)
{
if (encoded)
{
argument = EncodeArgument(argument);
}
return
(SF.ExpressionStatement(
SF.InvocationExpression(
SF.ParseExpression("sb.Append")
)
.AddArgumentListArguments(
argument
)
));
}
public static string GenerateClass()
{
var @consoleWriteLine = Syntax.MemberAccessExpression(SyntaxKind.SimpleMemberAccessExpression,
Syntax.IdentifierName("Console"),
name: Syntax.IdentifierName("WriteLine"));
var @arguments = Syntax.ArgumentList(Syntax.SeparatedList(new[] {
Syntax.Argument(
Syntax.LiteralExpression(
SyntaxKind.StringLiteralExpression,
Syntax.Literal(@"$""{this.Name} -> {this.counter}""", "${this.Name} -> {this.counter}")))
}));
var @consoleWriteLineStatement = Syntax.ExpressionStatement(Syntax.InvocationExpression(@consoleWriteLine, @arguments));
var @voidType = Syntax.ParseTypeName("void");
var @stringType = Syntax.ParseTypeName("string");
var @field = Syntax.FieldDeclaration(Syntax.VariableDeclaration(Syntax.ParseTypeName("int"), Syntax.SeparatedList(new[] { Syntax.VariableDeclarator(Syntax.Identifier("counter")) }))).AddModifiers(Syntax.Token(SyntaxKind.PrivateKeyword)).WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken));
var @property = Syntax.PropertyDeclaration(stringType, "Name").AddAccessorListAccessors(Syntax.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)
)).AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword));
@property = @property.AddAccessorListAccessors(Syntax.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration).WithSemicolonToken(Syntax.Token(SyntaxKind.SemicolonToken)));
var @printMethod = Syntax.MethodDeclaration(voidType, "Print").AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).WithBody(Syntax.Block(consoleWriteLineStatement));
List <ParameterSyntax> @parameterList = new List <ParameterSyntax>
{
Syntax.Parameter(Syntax.Identifier("x")).WithType(Syntax.ParseTypeName("int"))
};
var @methodBody = Syntax.ParseStatement("counter += x;");
var @incrementMethod = Syntax.MethodDeclaration(voidType, "Increment").AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).WithBody(Syntax.Block(methodBody)).AddParameterListParameters(parameterList.ToArray());
var @class = Syntax.ClassDeclaration("MyClass").WithMembers(Syntax.List(new MemberDeclarationSyntax[] { @property, @field, @incrementMethod, @printMethod })).AddModifiers(Syntax.Token(SyntaxKind.PublicKeyword)).AddModifiers(Syntax.Token(SyntaxKind.SealedKeyword));
var adhocWorkSpace = new AdhocWorkspace();
adhocWorkSpace.Options.WithChangedOption(CSharpFormattingOptions.IndentBraces, true);
var formattedCode = Formatter.Format(@class, adhocWorkSpace);
return(formattedCode.ToFullString());
}
/// <summary>
/// sb.Append(Template.Render(membername))
/// </summary>
/// <param name="templateTypeName"></param>
/// <param name="memberName"></param>
/// <returns></returns>
internal static ExpressionStatementSyntax HbsTemplateCall(string templateTypeName, string memberName, string methodName = "Render")
{
return
(SF.ExpressionStatement(
SF.InvocationExpression(
SF.ParseExpression("sb.Append")
)
.AddArgumentListArguments(
SF.Argument(
SF.InvocationExpression(
SF.ParseExpression($"{templateTypeName}.{methodName}")
).AddArgumentListArguments(
SF.Argument(SF.ParseExpression(memberName))
)
)
)
));
}
internal static ExpressionStatementSyntax SelfReferencingPartialCall(string memberName)
{
return
(SF.ExpressionStatement(
SF.InvocationExpression(
SF.ParseExpression("sb.Append")
)
.AddArgumentListArguments(
SF.Argument(
SF.InvocationExpression(
SF.ParseExpression("Render")
).AddArgumentListArguments(
SF.Argument(SF.ParseExpression(memberName))
)
)
)
));
}
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()))));
}
/// <summary>
/// Generates a method.
/// </summary>
/// <param name="methodDescription">
/// The method description.
/// </param>
/// <returns>
/// The generated method.
/// </returns>
/// <exception cref="ArgumentException">
/// The return type of the provided method is not supported.
/// </exception>
private static MethodDeclarationSyntax GenerateMethod(ActorMethodDescription methodDescription)
{
// Types
var method = methodDescription.MethodInfo;
Type asyncReturnType;
if (!method.ReturnType.IsGenericType && (method.ReturnType == typeof(Task)))
{
asyncReturnType = typeof(void);
}
else if (method.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
asyncReturnType = method.ReturnType.GenericTypeArguments[0];
}
else
{
throw new ArgumentException("Method return type is not Task or Task<T>.");
}
// Body statements
var parameterReferences =
method.GetParameters()
.Select(
p => SF.Argument(SF.CastExpression(typeof(object).GetTypeSyntax(), SF.IdentifierName(p.Name))))
.ToArray();
var writeEventMethod = SF.ThisExpression().Member((EventProducerBase <object> _) => _.WriteEvent(default(string), default(object), default(object)));
var writeEvent =
SF.ExpressionStatement(
SF.AwaitExpression(
SF.InvocationExpression(writeEventMethod)
.AddArgumentListArguments(SF.Argument(methodDescription.Name.GetLiteralExpression()))
.AddArgumentListArguments(parameterReferences)));
var returnValue = asyncReturnType == typeof(void) ? null : SF.DefaultExpression(asyncReturnType.GetTypeSyntax());
// Build and return the method.
return
(SF.MethodDeclaration(method.ReturnType.GetTypeSyntax(), methodDescription.MethodInfo.Name)
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.AsyncKeyword))
.AddParameterListParameters(method.GetParameterListSyntax())
.AddBodyStatements(writeEvent, SF.ReturnStatement(returnValue)));
}
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())
));
}
private static ConstructorDeclarationSyntax MakeConstructor(
TypeDeclarationSyntax type, IEnumerable <Field> fields,
ConstructorDeclarationSyntax maybePreviousConstructor)
{
var fieldsList = fields.ToList();
var constructorParameters = SF.ParameterList(
SF.SeparatedList(
fieldsList.Select(
field => SF.Parameter(SF.Identifier(field.Name))
.WithType(field.Type)
.WithAttributeLists(field.Attributes)
)
)
);
var constructorBodyStatements = fieldsList.Select(
field => SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
SF.MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression, SF.ThisExpression(), SF.IdentifierName(field.Name)
), SF.IdentifierName(field.Name)
)
)
);
var previousAttributes = maybePreviousConstructor?.AttributeLists ?? new SyntaxList <AttributeListSyntax>();
var res = SF.ConstructorDeclaration(type.Identifier.Text)
.WithAttributeLists(previousAttributes)
.WithModifiers(SF.TokenList(new[] { SF.Token(SyntaxKind.PublicKeyword) }))
.WithParameterList(constructorParameters)
.WithBody(SF.Block(constructorBodyStatements));
res = fieldsList.Any(x => x.StructuredTrivia != null) ? res.WithLeadingTrivia(
MakeXmlDocComments(maybePreviousConstructor, fieldsList, Constants.DefaultCtorSummary)
) :
maybePreviousConstructor?.HasLeadingTrivia ?? false?
res.WithLeadingTrivia(maybePreviousConstructor.GetLeadingTrivia()) : res;
return(res);
}
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);
}
/// <summary>
/// Returns syntax for the serializer registration method.
/// </summary>
/// <param name="type">The type.</param>
/// <returns>Syntax for the serializer registration method.</returns>
private static MemberDeclarationSyntax GenerateRegisterMethod(Type type)
{
Expression<Action> register =
() =>
SerializationManager.Register(
default(Type),
default(SerializationManager.DeepCopier),
default(SerializationManager.Serializer),
default(SerializationManager.Deserializer));
return
SF.MethodDeclaration(typeof(void).GetTypeSyntax(), "Register")
.AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters()
.AddBodyStatements(
SF.ExpressionStatement(
register.Invoke()
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(type.GetTypeSyntax())),
SF.Argument(SF.IdentifierName("DeepCopier")),
SF.Argument(SF.IdentifierName("Serializer")),
SF.Argument(SF.IdentifierName("Deserializer")))));
}
public override void Exit()
{
List <StatementSyntax> loopStatements = new List <StatementSyntax>();
//loopStatements.Add(StateHelper.MakeStatePushStatement());
loopStatements.Add(SF.ExpressionStatement(
SF.AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
VariableHelper.MakeStateVariableExpression(_asVariableName),
SF.IdentifierName(_iteratorVariableName)
)
)
);
if (_hookName != null)
{
loopStatements.Add(BlockContext.MakeWriteStatement(MethodCallContext.CreateMethodCall(_hookName, true)));
}
//loopStatements.Add(StateHelper.MakeStatePopWriteStatement());
var forEachStatement = SF.ForEachStatement(SF.ParseTypeName("var"), _iteratorVariableName, _expression, SF.Block(loopStatements));
_exitHandler(forEachStatement);
}
private static MemberDeclarationSyntax GeneratePopulateMethod(List <GrainClassDescription> grains)
{
var interfaceMethod = TypeUtils.Method((IFeaturePopulator <GrainClassFeature> _) => _.Populate(default(GrainClassFeature)));
var featureParameter = interfaceMethod.GetParameters()[0].Name.ToIdentifierName();
var grainsMember = TypeUtils.Member((GrainClassFeature feature) => feature.Classes);
var addMethod = TypeUtils.Method((IList <GrainClassMetadata> _) => _.Add(default(GrainClassMetadata)));
var bodyStatements = new List <StatementSyntax>();
foreach (var metadata in grains)
{
var newMetadataExpression = SF.ObjectCreationExpression(typeof(GrainClassMetadata).GetTypeSyntax())
.AddArgumentListArguments(
SF.Argument(SF.TypeOfExpression(metadata.ClassType)));
bodyStatements.Add(
SF.ExpressionStatement(
SF.InvocationExpression(featureParameter.Member(grainsMember.Name).Member(addMethod.Name))
.AddArgumentListArguments(
SF.Argument(newMetadataExpression))));
}
return(interfaceMethod.GetDeclarationSyntax().AddBodyStatements(bodyStatements.ToArray()));
}