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 static MethodDeclarationSyntax CreateMethod(MethodGenerationData data)
{
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodName), "Trying to generate a method with null or empty method name!");
Debug.Assert(!string.IsNullOrEmpty(data.m_MethodReturnType), "Trying to generate a method with null or empty return type!");
Debug.Assert(data.m_MethodBodyStatements != null && data.m_MethodBodyStatements.Count > 0, "Trying to generate a method with no body!");
MethodDeclarationSyntax syntax = SyntaxFactory
.MethodDeclaration(SyntaxFactory.ParseTypeName(data.m_MethodReturnType), data.m_MethodName)
.AddModifiers(CodeGenerationUtility.CreateProtectionLevelToken(data.m_ProtectionLevel));
switch (data.m_InheritanceKeyword)
{
case FunctionInheritanceKeyword.STATIC: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword)); break;
case FunctionInheritanceKeyword.OVERRIDE: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.OverrideKeyword)); break;
case FunctionInheritanceKeyword.VIRTUAL: syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)); break;
}
if (data.m_IsAsync)
{
bool canMakeAsync = false;
for (int i = 0; i < s_AcceptedAsyncReturnTypes.Length; i++)
{
if (!data.m_MethodReturnType.Contains(s_AcceptedAsyncReturnTypes[i]))
{
continue;
}
canMakeAsync = true;
break;
}
Debug.Assert(canMakeAsync, "Trying to generate async function but the return type is not supported! Please make the return type either void, Task or UniTask");
if (canMakeAsync)
{
syntax = syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
}
syntax = syntax.AddAttributeLists(AttributeGenerationService.CreateAttributeListSyntaxes(data.m_Attributes));
foreach (var param in data.m_MethodParams)
{
syntax = syntax.AddParameterListParameters(CodeGenerationUtility.CreateParameterSyntax(param.m_ParamName, param.m_ParamType));
}
foreach (var statement in data.m_MethodBodyStatements)
{
syntax = syntax.AddBodyStatements((SyntaxFactory.ParseStatement(statement)));
}
return(syntax);
}
public override SyntaxNode VisitMethodDeclaration(MethodDeclarationSyntax node)
{
if (node.Parent is not ClassDeclarationSyntax classDeclaration)
{
return(node);
}
// Note: this won't work if the method is in one part of a partial class and only the other part has the sealed modifier
if (classDeclaration.Modifiers.Any(SealedKeyword))
{
return(node);
}
var modifiers = node.Modifiers;
var forbiddenModifiers = new[] { StaticKeyword, SealedKeyword, VirtualKeyword, OverrideKeyword };
var requiredModifiers = new[] { PublicKeyword, ProtectedKeyword, InternalKeyword };
if (forbiddenModifiers.Any(modifier => node.Modifiers.Any(modifier)) ||
!requiredModifiers.Any(modifier => node.Modifiers.Any(modifier)))
{
return(node);
}
return(node.AddModifiers(SyntaxFactory.Token(VirtualKeyword)));
}
private static MethodDeclarationSyntax MemberFunctionModifiers(MethodDeclarationSyntax method)
{
var modifiers = method.Modifiers;
if (!modifiers.Any(m => m.IsKind(SyntaxKind.StaticKeyword)))
{
method = method.AddModifiers(CSharp.Token(SyntaxKind.StaticKeyword));
}
if (!Roslyn.HasVisibilityModifier(method.Modifiers))
{
method = method.AddModifiers(CSharp.Token(SyntaxKind.PublicKeyword));
}
return(method);
}
private void GenerateIBuildsInterfaceImplementation(ClassGenerator @class)
{
@class.AddBaseType(GenericName("IBuilds").AddTypeArgumentListArguments(NameSyntax));
MethodDeclarationSyntax buildMethod = MethodDeclaration(returnType: NameSyntax, Identifier("Build"))
.AddModifiers(Token(SyntaxKind.PublicKeyword))
.AddBodyStatements(
ReturnStatement(
ObjectCreationExpression(NameSyntax)
.AddArgumentListArguments(Argument(ThisExpression()))));
ConversionOperatorDeclarationSyntax implicitCastOperator =
ConversionOperatorDeclaration(Token(SyntaxKind.ImplicitKeyword), NameSyntax)
.AddModifiers(Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword))
.AddParameterListParameters(
Parameter(Identifier("builder"))
.WithType(IdentifierName(BuilderClassName)))
.AddBodyStatements(
ReturnStatement(
InvocationExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("builder"),
IdentifierName("Build")))));
if (BaseClass != null)
{
buildMethod = buildMethod.AddModifiers(Token(SyntaxKind.NewKeyword));
}
@class.AddMembers(buildMethod, implicitCastOperator);
}
/// <summary>
/// Initializing of visitor
/// </summary>
public RoslynTreeBuilderVisitor(string libraryModuleName = null)
{
//Create unit
unitNode = CompilationUnit();
//Create public class "Program" (or library unit's name)
this.libraryModuleName = libraryModuleName;
string className = libraryModuleName ?? "$Program";
programClassNode = ClassDeclaration(className).AddModifiers(Token(SyntaxKind.PublicKeyword));
//Create method void Main()
mainMethodNode = MethodDeclaration(PredefinedType(Token(SyntaxKind.VoidKeyword)), "Main");
//Set Main method as static
mainMethodNode = mainMethodNode.AddModifiers(Token(SyntaxKind.StaticKeyword));
//Add to Main method empty body
mainMethodNode = mainMethodNode.AddBodyStatements();
//Set Main method as current block (push to stack)
blocks.Push(mainMethodNode);
//initialize dictionary of location annotations
LocationAnnotations = new List <SyntaxAnnotation>();
}
public static MethodDeclarationSyntax AddModifiers(this MethodDeclarationSyntax cl, params SyntaxKind[] modifiers)
{
if (modifiers == null)
{
return(cl);
}
return(cl.AddModifiers(modifiers.Select(x => SyntaxFactory.Token(x)).ToArray()));
}
public static MethodDeclarationSyntax WithStatic(this MethodDeclarationSyntax syntax, bool isStatic)
{
if (isStatic)
{
return(syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword)));
}
else
{
return(syntax.WithModifiers(SyntaxFactory.TokenList()));
}
}
private MethodDeclarationSyntax CreateTestMethod(string methodName)
{
AttributeListSyntax attributes = SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(
SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("TestMethod")))
).NormalizeWhitespace();
MethodDeclarationSyntax testMethod = SyntaxFactory.MethodDeclaration(SyntaxFactory.ParseTypeName("void"), "Test" + methodName);
testMethod = testMethod.AddModifiers(SyntaxFactory.Token(SyntaxKind.PublicKeyword)).AddAttributeLists(attributes).AddBodyStatements(SyntaxFactory.ParseStatement("Assert.Fail(\"autogenerated\");"));
return(testMethod);
}
private static Solution UpdateMainDocument(Document document, SyntaxNode root, MethodDeclarationSyntax method, IEnumerable <IGrouping <Document, ReferenceLocation> > documentGroups)
{
var mainDocGroup = documentGroups.FirstOrDefault(dg => dg.Key.Equals(document));
SyntaxNode newRoot;
if (mainDocGroup == null)
{
newRoot = root.ReplaceNode(method, method.AddModifiers(staticToken));
}
else
{
var diagnosticNodes = mainDocGroup.Select(referenceLocation => root.FindNode(referenceLocation.Location.SourceSpan)).ToList();
newRoot = root.TrackNodes(diagnosticNodes.Union(new[] { method }));
newRoot = newRoot.ReplaceNode(newRoot.GetCurrentNode(method), method.AddModifiers(staticToken));
foreach (var diagnosticNode in diagnosticNodes)
{
var token = newRoot.FindToken(diagnosticNode.GetLocation().SourceSpan.Start);
var tokenParent = token.Parent;
if (token.Parent.IsKind(SyntaxKind.IdentifierName))
{
continue;
}
var invocationExpression = newRoot.GetCurrentNode(diagnosticNode).FirstAncestorOrSelfOfType <InvocationExpressionSyntax>()?.Expression;
if (invocationExpression == null || invocationExpression.IsKind(SyntaxKind.IdentifierName))
{
continue;
}
var memberAccess = invocationExpression as MemberAccessExpressionSyntax;
if (memberAccess == null)
{
continue;
}
var newMemberAccessParent = memberAccess.Parent.ReplaceNode(memberAccess, memberAccess.Name)
.WithAdditionalAnnotations(Formatter.Annotation);
newRoot = newRoot.ReplaceNode(memberAccess.Parent, newMemberAccessParent);
}
}
var newSolution = document.Project.Solution.WithDocumentSyntaxRoot(document.Id, newRoot);
return(newSolution);
}
private static SyntaxNode ConvertMethodToAsync(MethodDeclarationSyntax methodNode)
{
var token = methodNode.GetFirstToken();
var leadingTrivia = TriviaList();
if (methodNode.ReturnType.GetFirstToken() == token)
{
methodNode = methodNode.ReplaceToken(token, token.WithLeadingTrivia(leadingTrivia));
leadingTrivia = token.LeadingTrivia;
}
return(methodNode
.AddModifiers(Token(leadingTrivia, SyntaxKind.AsyncKeyword, TriviaList(Space)))
.WithAdditionalAnnotations(Formatter.Annotation));
}
public MemberDeclarationSyntax Generate(ILocatedOpenApiElement <OpenApiOperation> operation,
ILocatedOpenApiElement <OpenApiMediaType>?mediaType)
{
MethodDeclarationSyntax methodDeclaration = GenerateHeader(operation);
if (mediaType == null)
{
// In the base request class which has no body
methodDeclaration = methodDeclaration
.AddModifiers(Token(SyntaxKind.ProtectedKeyword), Token(SyntaxKind.VirtualKeyword))
.WithExpressionBody(ArrowExpressionClause(
LiteralExpression(SyntaxKind.NullLiteralExpression)));
}
else
{
// In an inherited request class which adds a body
methodDeclaration = methodDeclaration
.AddModifiers(Token(SyntaxKind.ProtectedKeyword), Token(SyntaxKind.OverrideKeyword))
.WithBody(Block(GenerateStatements(operation, mediaType)));
}
return(methodDeclaration);
}
private MethodDeclarationSyntax CreateFunctionDeclaration(FunctionDeclaration node)
{
MethodDeclarationSyntax methodDeclaration = SyntaxFactory.MethodDeclaration(node.Type.ToCsNode <TypeSyntax>(), node.Name.Text);
methodDeclaration = methodDeclaration.AddModifiers(node.Modifiers.ToCsNodes <SyntaxToken>());
methodDeclaration = methodDeclaration.AddParameterListParameters(node.Parameters.ToCsNodes <ParameterSyntax>());
if (node.JsDoc.Count > 0)
{
methodDeclaration = methodDeclaration.WithLeadingTrivia(SyntaxFactory.Trivia(node.JsDoc[0].ToCsNode <DocumentationCommentTriviaSyntax>()));
}
if (node.TypeParameters.Count > 0)
{
methodDeclaration = methodDeclaration.AddTypeParameterListParameters(node.TypeParameters.ToCsNodes <TypeParameterSyntax>());
}
return(methodDeclaration.WithBody(node.Body.ToCsNode <BlockSyntax>()));
}
private static MethodDeclarationSyntax singletonPublicSignal(MethodDeclarationSyntax method, out MethodDeclarationSyntax result)
{
result = method.WithIdentifier(CSharp.ParseToken("__" + method.Identifier.ToString()));
var sCall = method.ReturnType.ToString() == "void"
? Templates.SingletonCall
.Get <StatementSyntax>(result.Identifier.ToString())
: Templates.SingletonReturnCall
.Get <StatementSyntax>(result.Identifier.ToString());
return(method
.AddModifiers([email protected]())
.WithBody(CSharp.Block(sCall
.ReplaceNodes(sCall
.DescendantNodes()
.OfType <ArgumentListSyntax>(),
(on, nn) => nn.WithArguments(CSharp.SeparatedList(method
.ParameterList
.Parameters
.Select(parameter => CSharp.Argument(CSharp.IdentifierName(parameter.Identifier)))))))));
}
private MethodDeclarationSyntax CreateMethodDeclaration(IAnonymousFunctionOperation operation,
IFieldSymbol fieldSymbol,
BlockSyntax block, ArrowExpressionClauseSyntax arrow)
{
MethodDeclarationSyntax methodDecl =
((MethodDeclarationSyntax)CommonConversions.CsSyntaxGenerator.MethodDeclaration(operation.Symbol))
.WithIdentifier(SyntaxFactory.Identifier(fieldSymbol.Name))
.WithBody(block).WithExpressionBody(arrow);
if (operation.Symbol.IsAsync)
{
methodDecl = methodDecl.AddModifiers(SyntaxFactory.Token(SyntaxKind.AsyncKeyword));
}
if (arrow != null)
{
methodDecl = methodDecl.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
}
return(methodDecl);
}
public static void AddMacro(MethodDeclarationSyntax macro, string namespaceName, string className)
{
string methodName = macro.Identifier.ToString();
var assemblies = new[]
{
typeof(SyntaxNode).GetTypeInfo().Assembly.Location,
typeof(SyntaxFactory).GetTypeInfo().Assembly.Location,
};
var program = MacroCompilationUnit
.AddMembers(NamespaceDeclaration(IdentifierName(namespaceName))
.AddMembers(ClassDeclaration(className)
.AddMembers(macro
.AddModifiers(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword) }))));
MacroStore[methodName] = new Lazy <MethodInfo>(() =>
{
var stream = Compiler.Compile(namespaceName, assemblies, OutputType.DynamicallyLinkedLibrary, program);
var macroFunc = AssemblyRunner.GetFunction(stream, namespaceName, className, methodName);
return(macroFunc);
});
}
public static MethodDeclarationSyntax AddModifiers(this MethodDeclarationSyntax syntax, params SyntaxKind[] modifier)
{
return(syntax.AddModifiers(modifier.Select(Token).ToArray()));
}
public void Generate()
{
// standard using directives
CompilationUnitSyntax cu = SyntaxFactory.CompilationUnit()
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Collections.Generic")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Linq")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Text")))
.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName("System.Threading.Tasks")));
NamespaceDeclarationSyntax localNamespace = SyntaxFactory.NamespaceDeclaration(SyntaxFactory.IdentifierName(directoryName));
ClassDeclarationSyntax localClass = SyntaxFactory.ClassDeclaration(Name);
foreach (var member in Declarations)
{
switch (member.DeclarationType)
{
case "method":
var currentMethod = member as Method;
//currentMethod.Type is a string parsed from the uml diagram
MethodDeclarationSyntax method = SyntaxFactory.MethodDeclaration(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(currentMethod.Type)), currentMethod.Name);
List <SyntaxToken> mods = new List <SyntaxToken>();
foreach (var modifier in currentMethod.Modifiers)
{
mods.Add(SyntaxFactory.ParseToken(modifier));
}
method = method.AddModifiers(mods.ToArray());
SeparatedSyntaxList <ParameterSyntax> ssl = SyntaxFactory.SeparatedList <ParameterSyntax>();
foreach (var param in currentMethod.Arguments)
{
ParameterSyntax ps = SyntaxFactory.Parameter(
new SyntaxList <AttributeListSyntax>(),
new SyntaxTokenList(),
SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(param.Type)),
SyntaxFactory.Identifier(param.Name), null);
ssl = ssl.Add(ps);
}
method = method.AddParameterListParameters(ssl.ToArray());
// we add an exception to the body of an otherwise empty method
ThrowStatementSyntax notReady = SyntaxFactory.ThrowStatement(SyntaxFactory.ObjectCreationExpression(SyntaxFactory.IdentifierName("NotImplementedException"), SyntaxFactory.ArgumentList(), null));
method = method.AddBodyStatements(notReady);
localClass = localClass.AddMembers(method);
break;
case "field":
var currentField = member as Field;
SyntaxTokenList stl = new SyntaxTokenList();
foreach (var modifier in currentField.Modifiers)
{
stl = stl.Add(SyntaxFactory.ParseToken(modifier));
}
SeparatedSyntaxList <VariableDeclaratorSyntax> svd = SyntaxFactory.SeparatedList <VariableDeclaratorSyntax>();
svd = svd.Add(SyntaxFactory.VariableDeclarator(currentField.Name));
// currentField.Type is a string parsed from the uml diagram
VariableDeclarationSyntax variable = SyntaxFactory.VariableDeclaration(SyntaxFactory.ParseTypeName(currentField.Type), svd);
FieldDeclarationSyntax field = SyntaxFactory.FieldDeclaration(
new SyntaxList <AttributeListSyntax>(),
stl,
variable
);
localClass = localClass.AddMembers(field);
break;
}
}
localNamespace = localNamespace.AddMembers(localClass);
cu = cu.AddMembers(localNamespace);
AdhocWorkspace cw = new AdhocWorkspace();
OptionSet options = cw.Options;
cw.Options.WithChangedOption(CSharpFormattingOptions.IndentBraces, true);
SyntaxNode formattedNode = Formatter.Format(cu, cw, options);
formattedNode.WriteTo(writer);
}
private IEnumerable <MemberDeclarationSyntax> getMembers(Type type, TypeNameResolver typeNameResolver)
{
// TODO: Add static members to a manager interface. (Daniel Potter, 11/8/2017)
foreach (MemberInfo memberInfo in type.GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
if (memberInfo.GetCustomAttribute(typeof(System.Runtime.CompilerServices.CompilerGeneratedAttribute)) != null)
{
continue;
}
MemberExtensionKind extensionKind;
switch (memberInfo.MemberType)
{
case MemberTypes.Constructor:
// TODO: Constructors should be added to a manager interface. (Daniel
// Potter, 11/8/2017)
break;
case MemberTypes.Event:
var eventInfo = (EventInfo)memberInfo;
extensionKind = eventInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
EventFieldDeclarationSyntax eventDeclaration = getEvent(eventInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
eventDeclaration = eventDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(eventDeclaration);
break;
case MemberTypes.Field:
// TODO: Constants need to be handled somehow. (Daniel Potter, 11/8/2017)
break;
case MemberTypes.Method:
var methodInfo = (MethodInfo)memberInfo;
if (methodInfo.IsSpecialName)
{
continue;
}
extensionKind = methodInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
MethodDeclarationSyntax methodDeclaration = getMethod(methodInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
methodDeclaration = methodDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(methodDeclaration);
break;
case MemberTypes.Property:
var propertyInfo = (PropertyInfo)memberInfo;
extensionKind = propertyInfo.GetExtensionKind();
if (extensionKind == MemberExtensionKind.Override)
{
continue;
}
if (propertyInfo.GetIndexParameters().Length > 0)
{
IndexerDeclarationSyntax indexerDeclaration = getIndexer(propertyInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
indexerDeclaration = indexerDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(indexerDeclaration);
}
else
{
PropertyDeclarationSyntax propertyDeclaration = getProperty(propertyInfo, typeNameResolver);
if (extensionKind == MemberExtensionKind.New)
{
propertyDeclaration = propertyDeclaration
.AddModifiers(Token(SyntaxKind.NewKeyword));
}
yield return(propertyDeclaration);
}
break;
case MemberTypes.NestedType:
// TODO: Nested types need to be handled somehow. (Daniel Potter, 11/8/2017)
break;
default:
// TODO: Log these for diagnostics. (Daniel Potter, 11/8/2017)
break;
}
}
}
public static MethodDeclarationSyntax WithPublicModifier(this MethodDeclarationSyntax method) => method.AddModifiers(Token(SyntaxKind.PublicKeyword));
public static MethodDeclarationSyntax WithModifiers(this MethodDeclarationSyntax node, params SyntaxKind[] modifiers)
{
return(node.AddModifiers(CreateModifiers(modifiers)));
}
public static MethodDeclarationSyntax WithStatic(this MethodDeclarationSyntax syntax, bool isStatic)
=> isStatic?syntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.StaticKeyword))
: syntax.WithModifiers(SyntaxFactory.TokenList());
private static Task <Document> FixMissingStatic(Document contextDocument, SyntaxNode root, MethodDeclarationSyntax method)
{
return(Task.FromResult(contextDocument.WithSyntaxRoot(root.ReplaceNode(method, method.AddModifiers(Token(SyntaxKind.StaticKeyword))))));
}
public static MethodDeclarationSyntax AsVirtual(this MethodDeclarationSyntax methodDeclarationSyntax)
{
return(methodDeclarationSyntax.AddModifiers(SyntaxFactory.Token(SyntaxKind.VirtualKeyword)));
}