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