private static ImmutableArray<SyntaxKind> Fill(Array values, SyntaxKind[] exclude) { Requires.NotNull(values, nameof(values)); Requires.NotNull(exclude, nameof(exclude)); var SyntaxKinds = ImmutableArray.CreateBuilder<SyntaxKind>(values.Length); foreach (SyntaxKind SyntaxKind in values) { if (!exclude.Contains(SyntaxKind)) { SyntaxKinds.Add(SyntaxKind); } } return SyntaxKinds.ToImmutable(); }
public PropertyDeclarationSyntax Convert(MethodDeclarationSyntax method, SemanticModel semanticModel = null) { if (method.Body == null && method.ExpressionBody != null && AreAllParentClassesPartial(method)) { ISymbol methodSymbol = null; if (semanticModel != null) { methodSymbol = semanticModel.GetDeclaredSymbol(method); } var parentClass = (method.Parent as ClassDeclarationSyntax); var methodIsStatic = method.Modifiers.Any(SyntaxKind.StaticKeyword); var funcParamTypes = ( methodIsStatic ? new TypeSyntax[] { } : Enumerable.Repeat(GetTypeOfClass(parentClass), 1) ).Union( method.ParameterList.Parameters.AsEnumerable() .Select(p => p.Type.WithoutTrailingTrivia()) ) .Union( Enumerable.Repeat(method.ReturnType.WithoutTrailingTrivia(), 1) ); var funcTypesSeperatedList = SyntaxFactory.SeparatedList <TypeSyntax>(funcParamTypes); var funcTypedArgumentList = SyntaxFactory.TypeArgumentList(funcTypesSeperatedList); var funcIdentifier = SyntaxFactory.Identifier("Func"); var funcType = SyntaxFactory.GenericName(funcIdentifier, funcTypedArgumentList); var expressionIdentifier = SyntaxFactory.Identifier("Expression"); var expressionTypesSeperatedList = SyntaxFactory.SeparatedList <TypeSyntax>(Enumerable.Repeat(funcType, 1)); var expressionTypedArgumentList = SyntaxFactory.TypeArgumentList(expressionTypesSeperatedList); var expressionType = SyntaxFactory.GenericName(expressionIdentifier, expressionTypedArgumentList).WithTriviaFrom(method.ReturnType); var lambdaParameters = SyntaxFactory.ParameterList( methodIsStatic ? RemoveThisFromExtensionMethod(method) : BuildStaticParamsWith_this(method, parentClass) ).WithTrailingTrivia(SyntaxFactory.Space); var methodExpression = (CSharpSyntaxNode) new ThisOrImplicitThisTo_ThisRewriter(semanticModel, methodSymbol).Visit(method.ExpressionBody.Expression).WithLeadingTrivia(method.ExpressionBody.Expression.GetLeadingTrivia()); var lamdaExpression = SyntaxFactory.ParenthesizedLambdaExpression( SyntaxFactory.Token(SyntaxKind.None), lambdaParameters.WithLeadingTrivia(SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed, method.GetLeadingTrivia().Last()), method.ExpressionBody.ArrowToken, methodExpression); var propertyExpressionBody = SyntaxFactory.ArrowExpressionClause ( SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken), lamdaExpression ); var kindsToRemove = new SyntaxKind[] { SyntaxKind.VirtualKeyword, SyntaxKind.NewKeyword, SyntaxKind.OverrideKeyword }; var modifiers = SyntaxFactory.TokenList(method.Modifiers.Where(t => !kindsToRemove.Contains(t.Kind()))); if (!modifiers.Any(SyntaxKind.StaticKeyword)) { modifiers = SyntaxFactory.TokenList(modifiers.Union(Enumerable.Repeat(SyntaxFactory.Token(SyntaxKind.StaticKeyword).WithTrailingTrivia(SyntaxFactory.Space), 1))); } var propertyDec = SyntaxFactory.PropertyDeclaration( method.AttributeLists, modifiers, expressionType, null, SyntaxFactory.Identifier(method.Identifier.Text + "_Expression").WithTrailingTrivia(SyntaxFactory.Space), null, propertyExpressionBody, null, SyntaxFactory.Token(SyntaxKind.SemicolonToken).WithTrailingTrivia(SyntaxFactory.CarriageReturn, SyntaxFactory.LineFeed) ).WithLeadingTrivia(method.GetLeadingTrivia().Last()); return(propertyDec); } else { return(null); } }