private static SyntaxNode ProcessMemberFunction(SyntaxNode node, Scope scope) { var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>(); if (node is MethodDeclarationSyntax) { var method = node as MethodDeclarationSyntax; if (method.ReturnType.IsMissing) { document.change(method, ReturnType); return(method.WithReturnType(RoslynCompiler.@void)); } return(node); } //handle functions declared inside code blocks var statement = node .AncestorsAndSelf() .OfType <StatementSyntax>() .FirstOrDefault(); Debug.Assert(statement != null); //td: error, maybe? Debug.Assert(statement is ExpressionStatementSyntax); var invocation = (statement as ExpressionStatementSyntax) .Expression as InvocationExpressionSyntax; Debug.Assert(invocation != null); var function = invocation.Expression as IdentifierNameSyntax; Debug.Assert(function != null); BlockSyntax parent = statement.Parent as BlockSyntax; Debug.Assert(parent != null); //td: error, maybe? var body = RoslynCompiler.NextStatement(parent, statement) as BlockSyntax; if (body == null) { //td: error, function declaration must be followed by a block of code return(node); } //We are not allowed to modify parents, so schedule the removal of the code //And its insertion in the final lambda variable document.change(parent, RoslynCompiler.RemoveStatement(body)); document.change(statement, ProcessCodeFunction(function, body)); return(node); }
private static SyntaxNode ProcessMemberFunction(SyntaxNode node, Scope scope) { var document = scope.GetDocument <SyntaxToken, SyntaxNode, SemanticModel>(); if (node is MethodDeclarationSyntax) { var method = (node as MethodDeclarationSyntax) .AddParameterListParameters(CSharp .Parameter(Templates.ScopeToken) .WithType(Templates.ScopeType)); method = MemberFunctionModifiers(method); if (method.ReturnType.IsMissing) { method = method.WithReturnType(RoslynCompiler.@void); var calculateType = method.Body .DescendantNodes() .OfType <ReturnStatementSyntax>() .Any(); var isMember = method.Parent is TypeDeclarationSyntax; if (!isMember) { var service = scope.GetService <SyntaxToken, SyntaxNode, SemanticModel>(); return(service.MarkNode(Templates .NamespaceFunction .AddMembers((MemberDeclarationSyntax)document.change( method, LinkNamespaceFunction(calculateType))))); } return(calculateType ? document.change(method, CalculateReturnType) : method); } return(node); } //handle functions declared inside code blocks var statement = node .AncestorsAndSelf() .OfType <StatementSyntax>() .FirstOrDefault(); Debug.Assert(statement != null); //td: error, maybe? Debug.Assert(statement is ExpressionStatementSyntax); var invocation = (statement as ExpressionStatementSyntax) .Expression as InvocationExpressionSyntax; Debug.Assert(invocation != null); var function = invocation.Expression as IdentifierNameSyntax; Debug.Assert(function != null); BlockSyntax parent = statement.Parent as BlockSyntax; Debug.Assert(parent != null); //td: error, maybe? var body = RoslynCompiler.NextStatement(parent, statement) as BlockSyntax; if (body == null) { //td: error, function declaration must be followed by a block of code return(node); } //We are not allowed to modify parents, so schedule the removal of the code //And its insertion in the final lambda variable document.change(parent, RoslynCompiler.RemoveStatement(body)); document.change(statement, ProcessCodeFunction(function, body)); return(node); }