1046

Committed 27 Apr 2025 01:21PM UTC coverage: 92.705% (+0.6%) from 92.112%

Build # 1046

Build Type

push

appveyor

Committed by

Sholtee

Commit Message

Merge branch 'v10-preview1'

Run Details

4791 of 5168 relevant lines covered (92.71%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

97.56

/SRC/Private/Extensions/CodeAnalysisExtensions.cs

﻿/********************************************************************************
* CodeAnalysisExtensions.cs                                                     *
*                                                                               *
* Author: Denes Solti                                                           *
********************************************************************************/
using System;
using System.Collections.Generic;
using System.Linq;

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp;
using Microsoft.CodeAnalysis.CSharp.Syntax;

using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;

namespace Solti.Utils.Proxy.Internals
{
    internal static class CodeAnalysisExtensions
    {
        /// <summary>
        /// SyntaxNode1, SyntaxNode2, ....
        /// </summary>
        public static SeparatedSyntaxList<TNode> ToSyntaxList<T, TNode>(this IEnumerable<T> src, Func<T, int, TNode> factory) where TNode : SyntaxNode
        {
            List<SyntaxNodeOrToken> nodesAndTokens = [];

            int i = 0;

            foreach (T item in src)
            {
                if (i > 0) nodesAndTokens.Add
                (
                    Token(SyntaxKind.CommaToken)
                );

                nodesAndTokens.Add
                (
                    factory(item, i++)
                );
            }

            return SeparatedList<TNode>(nodesAndTokens);
        }

        /// <summary>
        /// SyntaxNode1, SyntaxNode2, ....
        /// </summary>
        public static SeparatedSyntaxList<TNode> ToSyntaxList<T, TNode>(this IEnumerable<T> src, Func<T, TNode> factory) where TNode : SyntaxNode => ToSyntaxList(src, (p, i) => factory(p));

        /// <summary>
        /// SyntaxNode1, SyntaxNode2, ....
        /// </summary>
        public static SeparatedSyntaxList<TNode> ToSyntaxList<TNode>(this IEnumerable<TNode> src) where TNode : SyntaxNode => ToSyntaxList(src, static x => x);

        /// <summary>
        /// Name1.Name2.Name3.....
        /// </summary>
        public static NameSyntax Qualify(this IEnumerable<NameSyntax> parts)
        {
            int count = parts.Count();
            return count switch
            {
                0 => throw new InvalidOperationException(),
                1 => parts.Single(),
                _ => QualifiedName
                (
                    left: Qualify(parts.Take(count - 1)),
                    right: (SimpleNameSyntax) parts.Last()
                )
            };
        }

        public static LiteralExpressionSyntax AsLiteral(this string param) => LiteralExpression
        (
            SyntaxKind.StringLiteralExpression,
            Literal(param)
        );

        public static LiteralExpressionSyntax AsLiteral(this int param) => LiteralExpression
        (
            SyntaxKind.NumericLiteralExpression,
            Literal(param)
        );
    }
}

1	/********************************************************************************
2	* CodeAnalysisExtensions.cs *
3	* *
4	* Author: Denes Solti *
5	********************************************************************************/
6	using System;
7	using System.Collections.Generic;
8	using System.Linq;
9
10	using Microsoft.CodeAnalysis;
11	using Microsoft.CodeAnalysis.CSharp;
12	using Microsoft.CodeAnalysis.CSharp.Syntax;
13
14	using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
15
16	namespace Solti.Utils.Proxy.Internals
17	{
18	internal static class CodeAnalysisExtensions
19	{
20	/// <summary>
21	/// SyntaxNode1, SyntaxNode2, ....
22	/// </summary>
23	public static SeparatedSyntaxList<TNode> ToSyntaxList<T, TNode>(this IEnumerable<T> src, Func<T, int, TNode> factory) where TNode : SyntaxNode
24	{	1✔
25	List<SyntaxNodeOrToken> nodesAndTokens = [];	1✔
26
27	int i = 0;	1✔
28
29	foreach (T item in src)	1✔
30	{	1✔
31	if (i > 0) nodesAndTokens.Add	1✔
32	(	1✔
33	Token(SyntaxKind.CommaToken)	1✔
34	);	1✔
35
36	nodesAndTokens.Add	1✔
37	(	1✔
38	factory(item, i++)	1✔
39	);	1✔
40	}	1✔
41
42	return SeparatedList<TNode>(nodesAndTokens);	1✔
43	}	1✔
44
45	/// <summary>
46	/// SyntaxNode1, SyntaxNode2, ....
47	/// </summary>
48	public static SeparatedSyntaxList<TNode> ToSyntaxList<T, TNode>(this IEnumerable<T> src, Func<T, TNode> factory) where TNode : SyntaxNode => ToSyntaxList(src, (p, i) => factory(p));	1✔
49
50	/// <summary>
51	/// SyntaxNode1, SyntaxNode2, ....
52	/// </summary>
53	public static SeparatedSyntaxList<TNode> ToSyntaxList<TNode>(this IEnumerable<TNode> src) where TNode : SyntaxNode => ToSyntaxList(src, static x => x);	1✔
54
55	/// <summary>
56	/// Name1.Name2.Name3.....
57	/// </summary>
58	public static NameSyntax Qualify(this IEnumerable<NameSyntax> parts)
59	{	1✔
60	int count = parts.Count();	1✔
61	return count switch	1✔
62	{	1✔
63	0 => throw new InvalidOperationException(),	×
64	1 => parts.Single(),	1✔
65	_ => QualifiedName	1✔
66	(	1✔
67	left: Qualify(parts.Take(count - 1)),	1✔
68	right: (SimpleNameSyntax) parts.Last()	1✔
69	)	1✔
70	};	1✔
71	}	1✔
72
73	public static LiteralExpressionSyntax AsLiteral(this string param) => LiteralExpression	1✔
74	(	1✔
75	SyntaxKind.StringLiteralExpression,	1✔
76	Literal(param)	1✔
77	);	1✔
78
79	public static LiteralExpressionSyntax AsLiteral(this int param) => LiteralExpression	1✔
80	(	1✔
81	SyntaxKind.NumericLiteralExpression,	1✔
82	Literal(param)	1✔
83	);	1✔
84	}
85	}

Sholtee / proxygen / 1046

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous