private static IEnumerable <MethodDeclarationSyntax> GenerateApiControllerMethods(IEnumerable <MethodDeclarationSyntax> grainInterfaceMethods, string grainName)
{
var methodsDeclarations = new List <MethodDeclarationSyntax>();
foreach (var methodNode in grainInterfaceMethods)
{
// insert the id parameter at the end of the list of parameters
var idParam = RoslynUtils.CreateParameter("string", "id");
MethodDeclarationSyntax methodDclr = RoslynUtils.AppendParameterToMethod(methodNode, idParam);
methodDclr = methodDclr.AddModifiers(SF.Token(SyntaxKind.PublicKeyword)).WithSemicolonToken(SF.Token(SyntaxKind.None));
StatementSyntax getGrainStmt = SF.ParseStatement(string.Format(
"var grain = _grainFactory.GetGrain<{0}>(id);\n", grainName));
MethodInspector methodInspector = new MethodInspector(methodNode);
string callGrainStmt = string.Format("grain.{0}({1});",
methodInspector.MethodName, string.Join(", ", methodInspector.MethodParams.Keys));
if (methodInspector.ReturnType != "Task")
{
callGrainStmt = callGrainStmt.Insert(0, "return ");
}
else
{
callGrainStmt = callGrainStmt.Insert(0, "await ");
methodDclr = methodDclr.AddModifiers(SF.Token(SyntaxKind.AsyncKeyword));
}
StatementSyntax returnStmt = SF.ParseStatement(callGrainStmt);
methodsDeclarations.Add(methodDclr.WithBody(SF.Block(getGrainStmt, returnStmt)));
}
return(methodsDeclarations);
}
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel)
{
if (!methodSymbol.IsOrdinaryMethod())
{
return(classDclr);
}
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(
SF.ParseTypeName(methodSymbol.ReturnType.GetFullyQualifiedName()), methodSymbol.GetGenericName());
methodDclr = methodDclr.WithParameterList(methodDclr.ParameterList.AddParameters(
RoslynUtils.GetMethodParameterSyntaxList(methodSymbol).ToArray()));
methodDclr = methodDclr.WithSemicolonToken(SF.Token(SyntaxKind.None))
.WithExplicitInterfaceSpecifier(
SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
string delegateTypeName = NamingUtils.GetDelegateTypeName(methodSymbol, stubbedInterface);
string parameters = StubbingUtils.FormatParameters(methodSymbol);
var outParameters = methodSymbol.Parameters.Where(p => p.RefKind == RefKind.Out);
var methodBlock = StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, methodSymbol.GetGenericName(),
parameters, outParameters, methodSymbol.ReturnType, semanticModel);
classDclr = classDclr.AddMembers(methodDclr.WithBody(methodBlock));
return(classDclr);
}
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol,
INamedTypeSymbol stubbedInterface)
{
if (!methodSymbol.IsOrdinaryMethod())
{
return(classDclr);
}
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(
SF.ParseTypeName(methodSymbol.ReturnType.GetFullyQualifiedName()), methodSymbol.GetGenericName());
methodDclr = methodDclr.WithParameterList(methodDclr.ParameterList.AddParameters(
RoslynUtils.GetMethodParameterSyntaxList(methodSymbol).ToArray()));
methodDclr = methodDclr.WithSemicolonToken(SF.Token(SyntaxKind.None))
.WithExplicitInterfaceSpecifier(
SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
string delegateTypeName = NamingUtils.GetDelegateTypeName(methodSymbol, stubbedInterface);
string parameters = StubbingUtils.FormatParameters(methodSymbol);
string callDelegateStmt = StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, methodSymbol.GetGenericName(), parameters);
if (!methodSymbol.ReturnsVoid)
{
callDelegateStmt = callDelegateStmt.Insert(0, "return ");
}
classDclr = classDclr.AddMembers(
methodDclr.WithBody(SF.Block(SF.ParseStatement(callDelegateStmt))));
return(classDclr);
}
private BlockSyntax WrapByUsingStatements(
IEnumerable <ParameterDescription> parametersDescription,
BlockSyntax body)
{
StatementSyntax currentStatement = null;
foreach (var parameter in parametersDescription)
{
if (JavaUtils.IsPrimitive(parameter.Type))
{
continue;
}
var childBody = currentStatement ?? body;
currentStatement = RoslynUtils.UsingStatement(
"var",
$"{parameter.Name}_using",
GetExpressionFor(parameter),
childBody);
}
return(currentStatement == null
? body
: SyntaxFactory.Block(currentStatement));
}
public static List <object> SelectFx <TSource>(this IEnumerable <TSource> source, string selectorExpression)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrEmpty(selectorExpression))
{
throw new ArgumentException("Argument can't be null nor empty.", "selectorExpression");
}
selectorExpression = CodeUtils.PreprocessCode(selectorExpression);
Session session = RoslynUtils.CreateSession();
Exception exception;
Func <TSource, object> selector =
TryExecute <Func <TSource, object> >(selectorExpression, session, out exception);
if (selector != null)
{
return(source.Select(selector).ToList());
}
throw new ArgumentException(string.Format("Couldn't parse selector expression ('{0}') as Func<T, object>. TSource: '{1}'.", selectorExpression, typeof(TSource)), "selectorExpression", exception);
}
public CompilationUnitSyntax StubInterface(CompilationUnitSyntax cu, InterfaceDeclarationSyntax interfaceDclr,
SemanticModel semanticModel)
{
INamedTypeSymbol interfaceType = semanticModel.GetDeclaredSymbol(interfaceDclr);
NamespaceDeclarationSyntax namespaceNode = GetNamespaceNode(interfaceDclr);
string interfaceName = interfaceType.GetGenericName();
string stubName = NamingUtils.GetStubName(interfaceName);
ClassDeclarationSyntax classDclr = SF.ClassDeclaration(SF.Identifier(stubName))
.AddModifiers(SF.Token(RoslynUtils.GetVisibilityKeyword(interfaceType)))
.WithBaseList(RoslynUtils.BaseList(interfaceName))
.AddAttributeLists(AttributeListList(Attribute("CompilerGenerated")).ToArray());
classDclr = RoslynUtils.CopyGenericConstraints(interfaceType, classDclr);
classDclr = AddStubContainerField(classDclr, stubName);
classDclr = StubProperties(interfaceType, classDclr);
classDclr = StubMethods(interfaceType, classDclr);
string fullNameSpace = semanticModel.GetDeclaredSymbol(namespaceNode).ToString();
NamespaceDeclarationSyntax namespaceDclr = SF.NamespaceDeclaration(SF.IdentifierName(fullNameSpace))
.WithUsings(namespaceNode.Usings);
namespaceDclr = namespaceDclr.AddMembers(classDclr);
cu = cu.AddMembers(namespaceDclr);
return(cu);
}
private ClassDeclarationSyntax GenerateReadReplicaGrain(ClassDeclarationSyntax grainClass, ITypeSymbol swmrInterface)
{
string readReplicaGrainName = SwmrUtils.GetReadReplicaGrainName(grainClass.Identifier.Text);
string readReplicaInterfaceName = SwmrUtils.GetReadReplicaInterfaceName(swmrInterface.Name);
ClassDeclarationSyntax readReplicaGrain = GenerateClassSqueleton(readReplicaGrainName).WithBaseList(RoslynUtils.BaseList(new[] { "Grain", readReplicaInterfaceName }));
string grainStateTypeName = FindGrainStateTypeName(grainClass);
readReplicaGrain = readReplicaGrain.AddMembers(SF.FieldDeclaration(SF.VariableDeclaration(SF.ParseTypeName(grainStateTypeName), SF.SeparatedList(new[] { SF.VariableDeclarator(SF.Identifier("State")) }))).AddModifiers(SF.Token(SyntaxKind.PrivateKeyword)));
readReplicaGrain = readReplicaGrain.AddMembers(GenerateReadReplicaOnActivateAsync(swmrInterface));
foreach (ISymbol member in swmrInterface.GetMembers())
{
IMethodSymbol methodSymbol = member as IMethodSymbol;
if (methodSymbol == null || !IsReadOnlyMethod(methodSymbol))
{
continue;
}
MethodDeclarationSyntax methodImpl = RoslynUtils.FindImplementation(methodSymbol, grainClass);
readReplicaGrain = readReplicaGrain.AddMembers(methodImpl.WithLeadingTrivia(SF.EndOfLine("")));
}
readReplicaGrain = readReplicaGrain.AddMembers(GenerateSetStateMethod(grainStateTypeName));
return(readReplicaGrain);
}
private static IEnumerable <TSource> DoOrderByFx <TSource>(IEnumerable <TSource> source, string keySelectorExpression, Type keyType)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (string.IsNullOrEmpty(keySelectorExpression))
{
throw new ArgumentException("Argument can't be null nor empty.", "keySelectorExpression");
}
if (keyType == null)
{
throw new ArgumentNullException("keyType");
}
keySelectorExpression = CodeUtils.PreprocessCode(keySelectorExpression);
Session session = RoslynUtils.CreateSession();
Type keySelectorType = ReflectionUtils.CreateFuncType2(typeof(TSource), keyType);
Exception exception;
object keySelector =
TryExecute(keySelectorExpression, session, keySelectorType, out exception);
if (keySelector != null && keySelectorType.IsInstanceOfType(keySelector))
{
return(InvokeOrderBy(keyType, source, keySelector));
}
throw new ArgumentException(string.Format("Couldn't parse key selector expression ('{0}') as Func<TSource, TKey>. TSource: '{1}'. TKey: '{2}'.", keySelectorExpression, typeof(TSource), keyType), "keySelectorExpression");
}
public static IEnumerable <PropertyDeclarationSyntax> Build(
IEnumerable <MethodDescription> methodsDescription,
string classRefName,
string lockObjectName)
{
yield return(BuildProperty(classRefName, GenerateFindClassExpression(), lockObjectName));
foreach (var description in methodsDescription)
{
var isStatic = description.ModifiersDescriptions.Contains(ModifierDescription.STATIC);
var methodCallable = SyntaxFactory.IdentifierName(
$"Get{(isStatic ? "Static" : "")}Method");
var args = new List <ExpressionSyntax>
{
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(description.IsConstructor ? "<init>" : description.Name)),
SyntaxFactory.LiteralExpression(
SyntaxKind.StringLiteralExpression,
SyntaxFactory.Literal(
ServiceUtils.GetMethodJavaSignature(description)))
};
yield return(BuildProperty(
ServiceUtils.GetMethodRefName(description),
RoslynUtils.CallExpression(methodCallable, args),
lockObjectName));
}
}
private static StatementSyntax JvmReturnStatement()
{
return(RoslynUtils.CallExpression(
SyntaxFactory.IdentifierName("JvmManager")
.MemberAccessExpression("INSTANCE")
.MemberAccessExpression("GetEnv")
).ToStatement());
}
private static MethodDeclarationSyntax GenerateOnActivateAsyncMethod(int readReplicaCount)
{
return(RoslynUtils.ParseMethod(string.Format(
@"
public override async Task OnActivateAsync()
{{
_topology = SwmrUtils.CreateTopology(this.GetPrimaryKeyString(), {0});
await base.OnActivateAsync();
}}", readReplicaCount)));
}
private static ExpressionSyntax GenerateFindClassExpression()
{
var getEnvCallExpr = RoslynUtils.CallExpression(
SyntaxFactory.IdentifierName("JvmManager")
.MemberAccessExpression("INSTANCE")
.MemberAccessExpression("GetEnv"));
return(RoslynUtils.CallExpression(
getEnvCallExpr.MemberAccessExpression("FindClass")));
}
public MethodDeclarationSyntax GenerateSetStateMethod(string grainStateTypeName)
{
return(RoslynUtils.ParseMethod(string.Format(
@"
public Task SetState(GrainState state)
{{
State = state as {0};
return TaskDone.Done;
}}", grainStateTypeName)));
}
private static BlockSyntax AddNotNullStatement(this BlockSyntax blockSyntax, string fieldName,
ExpressionSyntax fieldIdentifierName)
{
var fieldNotNullStatement = RoslynUtils.CheckNullStatement(
fieldName,
SyntaxFactory.ReturnStatement(fieldIdentifierName),
invert: true
);
return(blockSyntax.AddStatements(fieldNotNullStatement));
}
private static DelegateDeclarationSyntax GenerateDelegateDclr(IMethodSymbol methodSymbol, string delegateName,
INamedTypeSymbol stubbedInterface)
{
SyntaxKind visibility = RoslynUtils.GetVisibilityKeyword(stubbedInterface);
List <ParameterSyntax> paramsSyntaxList = RoslynUtils.GetMethodParameterSyntaxList(methodSymbol);
DelegateDeclarationSyntax delegateDeclaration = SF.DelegateDeclaration(SF.ParseTypeName(methodSymbol.ReturnType.GetFullyQualifiedName()),
delegateName)
.AddModifiers(SF.Token(visibility)).AddParameterListParameters(paramsSyntaxList.ToArray());
delegateDeclaration = RoslynUtils.CopyGenericConstraints(methodSymbol, delegateDeclaration);
return(delegateDeclaration);
}
private static MethodDeclarationSyntax GenerateReadReplicaOnActivateAsync(ITypeSymbol swmrInterface)
{
return(RoslynUtils.ParseMethod(string.Format(
@"
public override async Task OnActivateAsync()
{{
string grainId = SwmrUtils.GetGrainId(this.GetPrimaryKeyString());
{0} grain = GrainFactory.GetGrain<{0}>(grainId);
await SetState(await grain.GetState());
await base.OnActivateAsync();
}}", swmrInterface.Name)));
}
private static MethodDeclarationSyntax GenerateMethodDeclaration(MethodInspector methodInspector)
{
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(SF.ParseTypeName(methodInspector.ReturnType), SF.Identifier(methodInspector.MethodName));
foreach (KeyValuePair <string, string> keyValuePair in methodInspector.MethodParams)
{
string paramType = keyValuePair.Value;
string paramName = keyValuePair.Key;
methodDclr = RoslynUtils.AppendParameterToMethod(methodDclr, RoslynUtils.CreateParameter(paramType, paramName));
}
return(methodDclr);
}
private static ClassDeclarationSyntax GenerateWriteGrain(ClassDeclarationSyntax grainClass, ITypeSymbol swmrInterface, int readReplicaCount)
{
string grainName = grainClass.Identifier.Text;
string writerGrainName = SwmrUtils.GetWriteInterfaceName(grainName);
string writerInterfaceName = SwmrUtils.GetWriteInterfaceName(swmrInterface.Name);
ClassDeclarationSyntax writerGrain = GenerateClassSqueleton(writerGrainName).WithBaseList(RoslynUtils.BaseList(new[] { "Grain", writerInterfaceName }));
writerGrain = RoslynUtils.AddField(writerGrain, "ITopology<string>", "_topology");
writerGrain = writerGrain.AddMembers(GenerateOnActivateAsyncMethod(readReplicaCount));
string readReplicaInterfaceName = SwmrUtils.GetReadReplicaInterfaceName(swmrInterface.Name);
foreach (ISymbol member in swmrInterface.GetMembers())
{
IMethodSymbol methodSymbol = member as IMethodSymbol;
if (methodSymbol == null || IsReadOnlyMethod(methodSymbol) || new MethodInspector(methodSymbol).MethodName == "GetState")
{
continue;
}
MethodInspector methodInspector = new MethodInspector(methodSymbol);
MethodDeclarationSyntax methodImpl = GenerateMethodDeclaration(methodInspector);
methodImpl = SwmrUtils.AddSessionIdParameter(methodImpl).AddModifiers(SF.Token(SyntaxKind.PublicKeyword), SF.Token(SyntaxKind.AsyncKeyword)).WithSemicolonToken(SF.Token(SyntaxKind.None));
BlockSyntax statmentBlock = SF.Block();
statmentBlock = AddStatement(statmentBlock, "string grainId = this.GetPrimaryKeyString();");
statmentBlock = AddStatement(statmentBlock, string.Format("{0} grain = GrainFactory.GetGrain<{0}>(grainId);", swmrInterface.Name));
statmentBlock = AddStatement(statmentBlock, String.Format("{0} await grain.{1}({2});", methodInspector.ReturnType != "Task"? "var result =" : "", methodInspector.MethodName, string.Join(", ", methodInspector.MethodParams.Keys)));
statmentBlock = AddStatement(statmentBlock, "GrainState state = await grain.GetState();");
statmentBlock = AddStatement(statmentBlock, "string sessionNode = _topology.GetNode(sessionId);");
statmentBlock = AddStatement(statmentBlock, "IEnumerable<string> otherNodes = _topology.Nodes.Where(node => node != sessionNode);");
ForEachStatementSyntax forEachStatement = SF.ForEachStatement(
SF.PredefinedType(SF.Token(SyntaxKind.StringKeyword)),
SF.Identifier("node"),
SF.IdentifierName("otherNodes"),
SF.Block(SF.ParseStatement(GenerateSetStateStmt(readReplicaInterfaceName, @"node")))
);
statmentBlock = statmentBlock.AddStatements(forEachStatement);
statmentBlock =
AddStatement(statmentBlock, (string.Format("{0} {1}", "await",
GenerateSetStateStmt(readReplicaInterfaceName, @"sessionNode"))));
if (methodInspector.ReturnType != "Task")
{
statmentBlock = AddStatement(statmentBlock, "return result;");
}
methodImpl = methodImpl.WithBody(statmentBlock);
writerGrain = writerGrain.AddMembers(methodImpl);
}
return(writerGrain);
}
private ClassDeclarationSyntax StubProperties(INamedTypeSymbol interfaceType, ClassDeclarationSyntax classDclr)
{
IEnumerable <IPropertySymbol> propertiesToStub = RoslynUtils.GetAllMembers <IPropertySymbol>(interfaceType);
foreach (IPropertySymbol propertySymbol in propertiesToStub)
{
foreach (IPropertyStubber propertyStubber in _propertyStubbers)
{
classDclr = propertyStubber.StubProperty(classDclr, propertySymbol, interfaceType);
}
}
return(classDclr);
}
private ClassDeclarationSyntax StubMethods(INamedTypeSymbol interfaceType, ClassDeclarationSyntax classDclr)
{
IEnumerable <IMethodSymbol> methodsToStub = RoslynUtils.GetAllMembers <IMethodSymbol>(interfaceType);
foreach (IMethodSymbol methodSymbol in methodsToStub)
{
foreach (IMethodStubber methodStubber in _methodStubbers)
{
classDclr = methodStubber.StubMethod(classDclr, methodSymbol, interfaceType);
}
}
return(classDclr);
}
private BlockSyntax GetConstrctorBody(MethodDescription description)
{
var callJvmExpression = CallJvmExpression(
"NewObject",
classRefName,
ServiceUtils.GetMethodRefProperty(description),
description.ParametersDescription);
return(SyntaxFactory.Block(
RoslynUtils
.AssignmentExpression(jObjectName, callJvmExpression)
.ToStatement()));
}
public static object Run(string code)
{
if (code == null)
{
throw new ArgumentNullException("code");
}
code = CodeUtils.PreprocessCode(code);
Session session = RoslynUtils.CreateSession();
return(session.Execute(code));
}
private ExpressionSyntax GetExpressionFor(ParameterDescription parameter)
{
var jvmEnvExpr = SyntaxFactory.IdentifierName("Env");
var jObjectsGettingExpressions = new Dictionary <string, ExpressionSyntax>
{
{ "string", RoslynUtils.CallExpression(
jvmEnvExpr.MemberAccessExpression("NewStringUtf"), new List <ExpressionSyntax>
{
SyntaxFactory.IdentifierName(parameter.Name)
}) }
};
return(jObjectsGettingExpressions[parameter.Type]);
}
private static BlockSyntax AddLockStatement(
this BlockSyntax blockSyntax,
string lockObjectName,
string fieldName,
ExpressionSyntax fieldIdentifierName,
ExpressionSyntax fieldAssignmentExpression)
{
var assignmentStatement = RoslynUtils.AssignmentExpression(fieldName, fieldAssignmentExpression);
var fieldNullStatement = RoslynUtils.CheckNullStatement(fieldName,
assignmentStatement.ToStatement());
var lockStat = RoslynUtils.LockStatement(
SyntaxFactory.IdentifierName(lockObjectName),
SyntaxFactory.Block(fieldNullStatement, SyntaxFactory.ReturnStatement(fieldIdentifierName))
);
return(blockSyntax.AddStatements(lockStat));
}
private ExpressionSyntax CallJvmExpression(string method, string callableObject,
string methodRefName, IEnumerable <ParameterDescription> arguments)
{
var newObjExpr = SyntaxFactory
.IdentifierName("Env")
.MemberAccessExpression(method);
var args = new List <ExpressionSyntax>
{
SyntaxFactory.IdentifierName(callableObject).MemberAccessExpression("Ptr"),
SyntaxFactory
.IdentifierName(methodRefName)
.MemberAccessExpression("Ptr"),
};
args.AddRange(arguments.Select(GenerateJValueExpressionFor));
return(RoslynUtils.CallExpression(newObjExpr, args));
}
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
var refSymbol = RoslynUtils.GetReferenceSymbol(node, _semanticModel);
if (refSymbol != null && RoslynUtils.IsVariableSymbol(refSymbol) && refSymbol.Locations[0].IsInSource)
{
var typeSymbol = RoslynUtils.GetVariableTypeSymbol(refSymbol);
if (typeSymbol.ToString() == _targetType)
{
_inScopeSymbols.Add(_tokenToLocation(node.GetLocation(), node.ToString()),
new ScopeData(SymbolToString(refSymbol),
new HashSet <String>(_semanticModel.LookupSymbols(node.GetLocation().SourceSpan.End).Where(s => RoslynUtils.IsVariableSymbol(s)).
Where(s => s.Locations[0].IsInSource).
Where(s => RoslynUtils.GetVariableTypeSymbol(s).ToString() == _targetType).Select(s => SymbolToString(s)))));
}
}
base.VisitIdentifierName(node);
}
private BasePropertyDeclarationSyntax CreatePropertyDclr(IMethodSymbol methodSymbol, string propType)
{
if (methodSymbol.IsIndexerAccessor())
{
IndexerDeclarationSyntax indexerDclr = SF.IndexerDeclaration(
SF.ParseTypeName(propType))
.WithExplicitInterfaceSpecifier(SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
indexerDclr = indexerDclr.AddParameterListParameters(
RoslynUtils.GetMethodParameterSyntaxList(methodSymbol).ToArray());
return(indexerDclr);
}
string propName = methodSymbol.AssociatedSymbol.Name;
PropertyDeclarationSyntax propDclr = SF.PropertyDeclaration(SF.ParseTypeName(propType), SF.Identifier(propName))
.WithExplicitInterfaceSpecifier(SF.ExplicitInterfaceSpecifier(
SF.IdentifierName(methodSymbol.GetContainingInterfaceGenericQualifiedName())));
return(propDclr);
}
private static MethodDeclarationSyntax GenerateSetupMethod(IMethodSymbol methodSymbol, string setupMethodName, string delegateTypeName,
INamedTypeSymbol stubbedInterface,
ClassDeclarationSyntax stub)
{
SyntaxKind visibility = RoslynUtils.GetVisibilityKeyword(stubbedInterface);
MethodDeclarationSyntax methodDclr = SF.MethodDeclaration(SF.ParseTypeName(stub.Identifier.Text), setupMethodName)
.AddModifiers(SF.Token(visibility)).WithSemicolonToken(SF.Token(SyntaxKind.SemicolonToken))
.AddParameterListParameters(
SF.Parameter(SF.Identifier("del")).WithType(SF.ParseTypeName(delegateTypeName)),
SF.Parameter(SF.Identifier("count")).WithType(SF.ParseTypeName("int")).WithDefault(SF.EqualsValueClause(SF.ParseExpression("Times.Forever"))),
SF.Parameter(SF.Identifier("overwrite")).WithType(SF.ParseTypeName("bool")).WithDefault(SF.EqualsValueClause(SF.ParseExpression("false")))
)
.WithBody(SF.Block(
SF.ParseStatement("_stubs.SetMethodStub(del, count, overwrite);\n"),
SF.ParseStatement("return this;\n")
))
.WithSemicolonToken(SF.Token(SyntaxKind.None));
return(RoslynUtils.CopyGenericConstraints(methodSymbol, methodDclr));
}
public string GetNodeType(SyntaxNodeOrToken node)
{
if (!_nodeToTypeStringCache.TryGetValue(node, out var res))
{
// Handle some literal types:
if (node.IsKind(SyntaxKind.StringLiteralToken))
{
res = "string";
}
else if (node.IsKind(SyntaxKind.CharacterLiteralToken))
{
res = "char";
}
else if (node.IsKind(SyntaxKind.NumericLiteralToken))
{
res = node.AsToken().Value.GetType().Name.ToLower();
}
else
{
var syntaxNode = node.IsNode ? node.AsNode() : node.AsToken().Parent;
if (syntaxNode != null)
{
ISymbol symbol = RoslynUtils.GetReferenceSymbol(syntaxNode, SemanticModel);
if (RoslynUtils.GetTypeSymbol(symbol, out var typeSymbol))
{
res = typeSymbol.ToString();
}
else
{
res = NOTYPE_NAME;
}
}
else
{
res = NOTYPE_NAME;
}
}
_nodeToTypeStringCache[node] = res;
}
return(res);
}
private static ClassDeclarationSyntax GenerateReadGrain(ClassDeclarationSyntax grainClass, ITypeSymbol swmrInterface, int readReplicaCount)
{
string readGrainName = SwmrUtils.GetReadInterfaceName(grainClass.Identifier.Text);
string readerInterfaceName = SwmrUtils.GetReadInterfaceName(swmrInterface.Name);
ClassDeclarationSyntax readGrain = GenerateClassSqueleton(readGrainName).WithAttributeLists(AttributeUtils.AttributeListList(AttributeUtils.Attribute(StatelessWorkerAttributeName))).WithBaseList(RoslynUtils.BaseList(new[] { "Grain", readerInterfaceName }));
readGrain = RoslynUtils.AddField(readGrain, "ITopology<string>", "_topology");
readGrain = readGrain.AddMembers(GenerateOnActivateAsyncMethod(readReplicaCount));
string readReplicaInterfaceName = SwmrUtils.GetReadReplicaInterfaceName(swmrInterface.Name);
foreach (ISymbol member in swmrInterface.GetMembers())
{
IMethodSymbol methodSymbol = member as IMethodSymbol;
if (methodSymbol == null || !IsReadOnlyMethod(methodSymbol))
{
continue;
}
MethodInspector methodInspector = new MethodInspector(methodSymbol);
string parameters = "string sessionId";
if (methodInspector.MethodParams.Any())
{
parameters = string.Join(", ", methodInspector.MethodParams.Select(param => string.Format("{0} {1}", param.Value, param.Key))) + " ," + parameters;
}
var method = RoslynUtils.ParseMethod(string.Format(
@"
public {0} {1}({2})
{{
string sessionNode = _topology.GetNode(sessionId);
var readReplica = GrainFactory.GetGrain<{3}>(sessionNode);
return readReplica.{1}({4});
}}", methodInspector.ReturnType, methodInspector.MethodName, parameters, readReplicaInterfaceName, string.Join(", ", methodInspector.MethodParams.Keys)));
readGrain =
readGrain.AddMembers(
method.WithLeadingTrivia(SF.EndOfLine("")));
}
return(readGrain);
}
