public IEnumerable <StatementSyntax> GetYields(IEnumerable <ExpressionSyntax> yields, int numYields) { if (numYields == 0) { yield break; } if (numYields > BufferSize) { throw new NotImplementedException(); } yield return(SF.IfStatement(SF.BinaryExpression(SyntaxKind.GreaterThanExpression, SF.IdentifierName(outputIndex), SH.Literal(BufferSize - numYields)), SF.Block( SF.ExpressionStatement(SF.IdentifierName(outputParameter).Dot("Write").Invoke(SF.IdentifierName(outputBuffer), SH.Literal(0), SF.IdentifierName(outputIndex))), SH.Assignment(SF.IdentifierName(outputIndex), SH.Literal(0))))); int index = 0; foreach (var yieldSyntax in yields) { yield return(SH.Assignment(SF.ElementAccessExpression(SF.IdentifierName(outputBuffer), SF.BracketedArgumentList(SF.SingletonSeparatedList(SF.Argument( SF.BinaryExpression(SyntaxKind.AddExpression, SF.IdentifierName(outputIndex), SH.Literal(index)))))), yieldSyntax)); ++index; } yield return(SH.Assignment(SF.IdentifierName(outputIndex), SH.Literal(numYields), SyntaxKind.AddAssignmentExpression)); }
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) { // only handle EventAdd and ignore EventRemove because we only need to stub the event once if (!methodSymbol.IsEventAdd()) { return(classDclr); } // add the event implementation to the stub IEventSymbol eventSymbol = (IEventSymbol)methodSymbol.AssociatedSymbol; EventFieldDeclarationSyntax eventDclr = ToEventDclr(eventSymbol); classDclr = classDclr.AddMembers(eventDclr); string eventName = eventSymbol.Name; ParameterSyntax[] parameters = GetEventParameters(eventSymbol); string onEventArgs = "sender"; string eventTriggerArgs = "sender"; if (parameters.Count() == 2) { onEventArgs += ", args"; eventTriggerArgs += ", args"; } else if (parameters.Count() == 1) { onEventArgs += ", null"; } string eventType = GetEventType(eventSymbol); string onEventMethodName = "On_" + eventName; // Create OnEvent method MethodDeclarationSyntax onEventMethodDclr = SF.MethodDeclaration(SF.ParseTypeName("void"), onEventMethodName) .AddModifiers(SF.Token(SyntaxKind.ProtectedKeyword)) .AddParameterListParameters(parameters) .WithBody(SF.Block( SF.ParseStatement($"{eventType} handler = {eventName};\n"), SF.ParseStatement($"if (handler != null) {{ handler({onEventArgs}); }}\n") )); classDclr = classDclr.AddMembers(onEventMethodDclr); // Create event trigger method string eventTriggerMethodName = eventName + "_Raise"; MethodDeclarationSyntax eventTriggerMethod = SF.MethodDeclaration(SF.ParseTypeName("void"), eventTriggerMethodName) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters(parameters) .WithBody(SF.Block( SF.ParseStatement($"{onEventMethodName}({eventTriggerArgs});\n") )); classDclr = classDclr.AddMembers(eventTriggerMethod); return(classDclr); }
public IEnumerable <StatementSyntax> GetMoveNext(StatementSyntax finalizer) { yield return(SF.IfStatement(SF.BinaryExpression(SyntaxKind.GreaterThanExpression, SF.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, SF.IdentifierName(bitIndex)), SH.Literal(7)), SF.Block(_wrapped.GetMoveNext(finalizer).Concat(new StatementSyntax[] { SH.Assignment(SF.IdentifierName(cachedInput), _wrapped.GetInput()), SH.Assignment(SF.IdentifierName(bitIndex), SH.Literal(0)) })), SF.ElseClause(SH.Assignment(SF.IdentifierName(cachedInput), SH.Literal(1), SyntaxKind.RightShiftAssignmentExpression)))); }
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 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 BlockSyntax Build() => SF.Block(expressions);
public ClassDeclarationSyntax StubProperty(ClassDeclarationSyntax classDclr, IPropertySymbol propertySymbol, INamedTypeSymbol stubbedInterface) { string indexerType = propertySymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); BasePropertyDeclarationSyntax propDclr = null; if (propertySymbol.GetMethod != null) { IMethodSymbol getMethodSymbol = propertySymbol.GetMethod; string parameters = StubbingUtils.FormatParameters(getMethodSymbol); string delegateTypeName = NamingUtils.GetDelegateTypeName(getMethodSymbol, stubbedInterface); var accessorDclr = SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, SF.Block( SF.List(new[] { SF.ParseStatement("return " + StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, getMethodSymbol.Name, parameters)) }))); propDclr = CreatePropertyDclr(getMethodSymbol, indexerType); propDclr = propDclr.AddAccessorListAccessors(accessorDclr); } if (propertySymbol.SetMethod != null) { IMethodSymbol setMethodSymbol = propertySymbol.SetMethod; string parameters = $"{StubbingUtils.FormatParameters(setMethodSymbol)}"; string delegateTypeName = NamingUtils.GetDelegateTypeName(setMethodSymbol, stubbedInterface); var accessorDclr = SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, SF.Block( SF.List(new[] { SF.ParseStatement(StubbingUtils.GenerateInvokeDelegateStmt(delegateTypeName, setMethodSymbol.Name, parameters)) }))); if (propDclr == null) { propDclr = CreatePropertyDclr(setMethodSymbol, indexerType); } propDclr = propDclr.AddAccessorListAccessors(accessorDclr); } classDclr = classDclr.AddMembers(propDclr); return(classDclr); }
public ClassDeclarationSyntax StubMethod(ClassDeclarationSyntax classDclr, IMethodSymbol methodSymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel) { // only handle EventAdd and ignore EventRemove because we only need to stub the event once if (!methodSymbol.IsEventAdd()) { return(classDclr); } // add the event implementation to the stub IEventSymbol eventSymbol = (IEventSymbol)methodSymbol.AssociatedSymbol; EventFieldDeclarationSyntax eventDclr = ToEventDclr(eventSymbol); classDclr = classDclr.AddMembers(eventDclr); string eventName = eventSymbol.Name; bool isCustomDelegateEvent = IsCustomDelegateBasedEvent(eventSymbol, semanticModel); ParameterSyntax[] parameters = GetEventParameters(eventSymbol, isCustomDelegateEvent); string onEventArgs; string eventTriggerArgs; string methodReturnType = "void"; string customDelegateReturnType = ""; bool hasReturnType = false; if (isCustomDelegateEvent) { IMethodSymbol delegateInvokeMethodSymbol = ((INamedTypeSymbol)(eventSymbol.OriginalDefinition).Type).DelegateInvokeMethod; onEventArgs = StubbingUtils.FormatParameters(delegateInvokeMethodSymbol); eventTriggerArgs = onEventArgs; if (!delegateInvokeMethodSymbol.ReturnsVoid) { hasReturnType = true; customDelegateReturnType = delegateInvokeMethodSymbol.ReturnType.GetFullyQualifiedName(); methodReturnType = $"global::System.Collections.Generic.IEnumerable<{customDelegateReturnType}>"; } } else { onEventArgs = "sender"; eventTriggerArgs = "sender"; if (parameters.Count() == 2) { onEventArgs += ", args"; eventTriggerArgs += ", args"; } else if (parameters.Count() == 1) { onEventArgs += ", null"; } } string eventType = GetEventType(eventSymbol); string onEventMethodName = "On_" + eventName; // Create OnEvent method BlockSyntax onEventMethodDclrBlock; if (hasReturnType) { onEventMethodDclrBlock = SF.Block( SF.ParseStatement($"{eventType} handler = {eventName};\n"), SF.ParseStatement("if (handler == null) {{ yield break; }}\n"), SF.ParseStatement($"foreach (var listener in handler.GetInvocationList()){{ if (listener.DynamicInvoke({onEventArgs}) is {customDelegateReturnType} ret){{ yield return ret; }} }}")); } else { onEventMethodDclrBlock = SF.Block( SF.ParseStatement($"{eventType} handler = {eventName};\n"), SF.ParseStatement($"if (handler != null) {{ handler({onEventArgs}); }}\n")); } MethodDeclarationSyntax onEventMethodDclr = SF.MethodDeclaration(SF.ParseTypeName(methodReturnType), onEventMethodName) .AddModifiers(SF.Token(SyntaxKind.ProtectedKeyword)) .AddParameterListParameters(parameters) .WithBody(onEventMethodDclrBlock); classDclr = classDclr.AddMembers(onEventMethodDclr); // Create event trigger method string eventTriggerMethodName = eventName + "_Raise"; BlockSyntax eventTriggerMethodBlock; if (hasReturnType) { eventTriggerMethodBlock = SF.Block(SF.ParseStatement($"return {onEventMethodName}({eventTriggerArgs});\n")); } else { eventTriggerMethodBlock = SF.Block(SF.ParseStatement($"{onEventMethodName}({eventTriggerArgs});\n")); } MethodDeclarationSyntax eventTriggerMethod = SF.MethodDeclaration(SF.ParseTypeName(methodReturnType), eventTriggerMethodName) .AddModifiers(SF.Token(SyntaxKind.PublicKeyword)) .AddParameterListParameters(parameters) .WithBody(eventTriggerMethodBlock); classDclr = classDclr.AddMembers(eventTriggerMethod); return(classDclr); }
public ClassDeclarationSyntax StubProperty(ClassDeclarationSyntax classDclr, IPropertySymbol propertySymbol, INamedTypeSymbol stubbedInterface, SemanticModel semanticModel) { string indexerType = propertySymbol.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat); BasePropertyDeclarationSyntax propDclr = null; if (propertySymbol.GetMethod != null) { IMethodSymbol getMethodSymbol = propertySymbol.GetMethod; string parameters = StubbingUtils.FormatParameters(getMethodSymbol); string delegateTypeName = NamingUtils.GetDelegateTypeName(getMethodSymbol, stubbedInterface); var accessorDclr = SF.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, SF.Block( SF.List(new[] { StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, getMethodSymbol.Name, parameters, Enumerable.Empty <IParameterSymbol>(), getMethodSymbol.ReturnType, semanticModel) }))); propDclr = CreatePropertyDclr(getMethodSymbol, indexerType); propDclr = propDclr.AddAccessorListAccessors(accessorDclr); } if (propertySymbol.SetMethod != null) { var voidType = semanticModel.Compilation.GetTypeByMetadataName("System.Void"); IMethodSymbol setMethodSymbol = propertySymbol.SetMethod; string parameters = $"{StubbingUtils.FormatParameters(setMethodSymbol)}"; string delegateTypeName = NamingUtils.GetDelegateTypeName(setMethodSymbol, stubbedInterface); var accessorDclr = SF.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration, SF.Block( SF.List(new[] { StubbingUtils.GetInvocationBlockSyntax(delegateTypeName, setMethodSymbol.Name, parameters, Enumerable.Empty <IParameterSymbol>(), voidType, semanticModel) }))); if (propDclr == null) { propDclr = CreatePropertyDclr(setMethodSymbol, indexerType); } propDclr = propDclr.AddAccessorListAccessors(accessorDclr); } classDclr = classDclr.AddMembers(propDclr); return(classDclr); }
public IEnumerable <StatementSyntax> GetMoveNext(StatementSyntax finalizer) { yield return(SF.IfStatement(SF.BinaryExpression(SyntaxKind.GreaterThanOrEqualExpression, SF.PrefixUnaryExpression(SyntaxKind.PreIncrementExpression, SF.IdentifierName(inputIndex)), SF.IdentifierName(read)), SF.Block( SH.Assignment(SF.IdentifierName(read), SF.IdentifierName(inputParameter).Dot("Read").Invoke(SF.IdentifierName(inputBuffer), SH.Literal(0), SF.IdentifierName(inputBuffer).Dot("Length"))), SF.IfStatement(SF.BinaryExpression(SyntaxKind.EqualsExpression, SF.IdentifierName(read), SH.Literal(0)), finalizer), SH.Assignment(SF.IdentifierName(inputIndex), SH.Literal(0)) ))); }