{

Class = 1,

Struct = 2,

ClassOrStruct = 3

{

Interface,

Abstract,

None

{

public static readonly TypeSyntax ExceptionType;

public static readonly TypeSyntax UnitType;

static CodeGenUtil()

{

var classInstances = QualifiedName(IdentifierName("LanguageExt"), IdentifierName("ClassInstances"));

ExceptionType = SystemType("Exception");

UnitType = ParseTypeName("LanguageExt.Unit");

}

public static void ReportInfo(string message, string codeGenCategory, SyntaxNode node, IProgress<Diagnostic> progress) =>

Report(message, codeGenCategory, DiagnosticSeverity.Info, node, progress);

public static void ReportWarning(string message, string codeGenCategory, SyntaxNode node, IProgress<Diagnostic> progress) =>

Report(message, codeGenCategory, DiagnosticSeverity.Warning, node, progress);

public static void ReportError(string message, string codeGenCategory, SyntaxNode node, IProgress<Diagnostic> progress) =>

Report(message, codeGenCategory, DiagnosticSeverity.Error, node, progress);

public static void Report(string message, string codeGenCategory, DiagnosticSeverity severity, SyntaxNode node, IProgress<Diagnostic> progress)

{

progress.Report(Diagnostic.Create(

new DiagnosticDescriptor(

$"CG{Math.Abs(message.GetHashCode()>>16)}",

message,

message,

codeGenCategory,

severity,

true,

message),

node.GetLocation()));

}

public static SyntaxToken VisibilityModifier(SyntaxTokenList tokens) =>

tokens.Where(t => t.Kind() == SyntaxKind.PublicKeyword ||

t.Kind() == SyntaxKind.PrivateKeyword ||

t.Kind() == SyntaxKind.InternalKeyword)

.DefaultIfEmpty(Token(SyntaxKind.PrivateKeyword))

.FirstOrDefault();

public static (TypeDeclarationSyntax PartialType, TypeSyntax ReturnType, List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> Fields) GetState(TransformationContext context, IProgress<Diagnostic> progress, AllowedType allowedTypes, string codeGenCategory)

{

// Our generator is applied to any class that our attribute is applied to.

var applyTo = (TypeDeclarationSyntax)context.ProcessingNode;

// Remove and re-add `partial`

var modifiers = TokenList(

Enumerable.Concat(

applyTo.Modifiers

.Where(t => !t.IsKind(SyntaxKind.PartialKeyword)).AsEnumerable(),

new[] { Token(SyntaxKind.PartialKeyword) }));

// Ensure class or struct

var partialType = applyTo switch

{

ClassDeclarationSyntax _ when (allowedTypes & AllowedType.Class) == AllowedType.Class =>

ClassDeclaration($"{applyTo.Identifier}").WithModifiers(modifiers),

StructDeclarationSyntax _ when (allowedTypes & AllowedType.Struct) == AllowedType.Struct =>

StructDeclaration($"{applyTo.Identifier}").WithModifiers(modifiers),

_ => (TypeDeclarationSyntax)null

};

if (partialType is null)

{

var error = allowedTypes switch

{

AllowedType.Class => "Type should be a struct",

AllowedType.Struct => "Type should be a class",

AllowedType.ClassOrStruct => "Type should be a class or struct",

_ => throw new NotSupportedException()

};

ReportError(error, codeGenCategory, applyTo, progress);

return default;

}

// Apply type params

if (applyTo.TypeParameterList != null)

{

partialType = partialType.WithTypeParameterList(applyTo.TypeParameterList);

}

// Apply type constraints

if (applyTo.ConstraintClauses != null)

{

partialType = partialType.WithConstraintClauses(applyTo.ConstraintClauses);

}

// Get the return type as a TypeSyntax

var returnType = TypeFromTypeDecl(applyTo);

// Provide an index for each member

var indexedMembers = applyTo.Members.Select((m, i) => (m, i)).ToList();

var fields = indexedMembers.Where(m => m.m is FieldDeclarationSyntax)

.Select(m => (f: m.m as FieldDeclarationSyntax, m.i))

.Where(m => m.f.Declaration.Variables.Count > 0)

.Where(m => FirstCharIsUpper(m.f.Declaration.Variables[0].Identifier.ToString()))

.Where(m => m.f.Modifiers.Any(SyntaxKind.PublicKeyword))

.Where(m => m.f.Modifiers.Any(SyntaxKind.ReadOnlyKeyword))

.Where(m => !m.f.Modifiers.Any(SyntaxKind.StaticKeyword))

.Select(m => (

m.f.Declaration.Variables[0].Identifier,

m.f.Declaration.Type,

m.f.Modifiers,

m.i,

m.f.AttributeLists

));

var properties = indexedMembers.Where(m => m.m is PropertyDeclarationSyntax)

.Select(m => (p: m.m as PropertyDeclarationSyntax, m.i))

.Where(m => FirstCharIsUpper(m.p.Identifier.ToString()))

.Where(m => m.p.Modifiers.Any(SyntaxKind.PublicKeyword))

.Where(m => !m.p.Modifiers.Any(SyntaxKind.StaticKeyword))

.Where(m => m.p.AccessorList != null && m.p.AccessorList.Accessors != null)

.Where(m => m.p.AccessorList.Accessors.Count == 1)

.Where(m => m.p.AccessorList.Accessors[0].Kind() == SyntaxKind.GetAccessorDeclaration)

.Where(m => m.p.AccessorList.Accessors[0].ExpressionBody == null)

.Where(m => m.p.AccessorList.Accessors[0].Body == null)

.Where(m => m.p.Initializer == null)

.Select(m => (

m.p.Identifier,

m.p.Type,

m.p.Modifiers,

m.i,

m.p.AttributeLists

));

var members = fields.Concat(properties)

.OrderBy(m => m.i) // Preserve the order between properties and fields.

.Select(m => (m.Identifier, m.Type, m.Modifiers, m.AttributeLists))

.ToList();

return (partialType, returnType, members);

}

internal static bool ForAll<A>(this IEnumerable<A> ma, Func<A, bool> f)

{

foreach(var a in ma)

{

if (!f(a)) return false;

}

return true;

}

internal static bool Exists<A>(this IEnumerable<A> ma, Func<A, bool> f)

{

foreach (var a in ma)

{

if (f(a)) return true;

}

return false;

}

public static TypeDeclarationSyntax AddLenses(TypeDeclarationSyntax partialClass, TypeSyntax returnType, List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> members)

{

TypeDeclarationSyntax lensClass = ClassDeclaration("__LensFields")

.WithModifiers(TokenList(Token(SyntaxKind.StaticKeyword)));

foreach (var member in members)

{

partialClass = AddLensProp(partialClass, returnType, member);

lensClass = AddLens(lensClass, returnType, member);

}

return partialClass.AddMembers(lensClass);

}

public static TypeDeclarationSyntax AddLensProp(TypeDeclarationSyntax partialClass, TypeSyntax returnType, (SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs) member) =>

partialClass.AddMembers(

PropertyDeclaration(

GenericName(Identifier("Lens"))

.WithTypeArgumentList(TypeArgumentList(SeparatedList<TypeSyntax>(new[] { returnType, member.Type }))),

Identifier(MakeCamelCaseId(member.Identifier).Text))

.WithModifiers(

TokenList(

new[]{

Token(SyntaxKind.PublicKeyword),

Token(SyntaxKind.StaticKeyword)}))

.WithExpressionBody(

ArrowExpressionClause(

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("__LensFields"),

IdentifierName(MakeCamelCaseId(member.Identifier).Text))))

.WithSemicolonToken(

Token(SyntaxKind.SemicolonToken)));

public static TypeDeclarationSyntax AddLens(TypeDeclarationSyntax partialClass, TypeSyntax returnType, (SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs) member)

{

var lfield = FieldDeclaration(

VariableDeclaration(

GenericName(Identifier("Lens"))

.WithTypeArgumentList(

TypeArgumentList(SeparatedList<TypeSyntax>(new[] { returnType, member.Type }))))

.WithVariables(

SingletonSeparatedList<VariableDeclaratorSyntax>(

VariableDeclarator(MakeCamelCaseId(member.Identifier))

.WithInitializer(

EqualsValueClause(

InvocationExpression(

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

GenericName("Lens")

.WithTypeArgumentList(

TypeArgumentList(

SeparatedList<TypeSyntax>(new[] { returnType, member.Type }))),

IdentifierName("New")))

.WithArgumentList(

ArgumentList(

SeparatedList<ArgumentSyntax>(

new SyntaxNodeOrToken[] {

Argument(

SimpleLambdaExpression(

Parameter(

Identifier("_x")),

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("_x"),

IdentifierName(MakeFirstCharUpper(member.Identifier))))),

Token(SyntaxKind.CommaToken),

Argument(

SimpleLambdaExpression(

Parameter(

Identifier("_x")),

SimpleLambdaExpression(

Parameter(

Identifier("_y")),

InvocationExpression(

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("_y"),

IdentifierName("With")))

.WithArgumentList(

ArgumentList(

SingletonSeparatedList<ArgumentSyntax>(

Argument(

IdentifierName("_x"))

.WithNameColon(

NameColon(MakeFirstCharUpper(member.Identifier.ToString()).ToString()))))))))

}))))))));

lfield = lfield.WithModifiers(

TokenList(

//Enumerable.Concat(

// member.Modifiers.Where(m => m.IsKind(SyntaxKind.PublicKeyword) || m.IsKind(SyntaxKind.PrivateKeyword) || m.IsKind(SyntaxKind.ProtectedKeyword)),

// new[] { Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.ReadOnlyKeyword) })

new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword), Token(SyntaxKind.ReadOnlyKeyword) })

);

return partialClass.AddMembers(lfield);

}

public static TypeDeclarationSyntax AddWith(TransformationContext context, TypeDeclarationSyntax partialClass, TypeSyntax returnType, List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> members)

{

var withParms = members.Select(m => (Id: m.Identifier,

Type: m.Type,

Info: context.SemanticModel.GetTypeInfo(m.Type),

Nlbl: m.Type is NullableTypeSyntax))

.Select(m => (m.Id,

m.Type,

m.Info,

IsGeneric: !m.Info.Type.IsValueType && !m.Info.Type.IsReferenceType,

ParamType: m.Info.Type.IsValueType && !m.Nlbl

? NullableType(m.Type)

: m.Type))

.Select(m =>

Parameter(MakeFirstCharUpper(m.Id))

.WithType(m.ParamType)

.WithDefault(

m.IsGeneric

? EqualsValueClause(DefaultExpression(m.Type))

: EqualsValueClause(LiteralExpression(SyntaxKind.NullLiteralExpression))))

.ToArray();

var withMethod = MethodDeclaration(returnType, "With")

.WithParameterList(ParameterList(SeparatedList<ParameterSyntax>(withParms)))

.WithModifiers(TokenList(

Token(SyntaxKind.PublicKeyword)))

.WithSemicolonToken(Token(SyntaxKind.SemicolonToken))

.WithExpressionBody(

ArrowExpressionClause(

ObjectCreationExpression(

returnType,

ArgumentList(

SeparatedList<ArgumentSyntax>(

withParms.Select(wa =>

Argument(

BinaryExpression(

SyntaxKind.CoalesceExpression,

IdentifierName(wa.Identifier),

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

ThisExpression(),

IdentifierName(wa.Identifier))))))), null)));

partialClass = partialClass.AddMembers(withMethod);

return partialClass;

}

public static TypeSyntax TypeFromTypeDecl(TypeDeclarationSyntax decl) =>

ParseTypeName($"{decl.Identifier}{decl.TypeParameterList}");

public static SyntaxToken MakeFirstCharUpper(SyntaxToken identifier)

{

var id = identifier.ToString();

var id2 = $"{Char.ToUpper(id[0])}{id.Substring(1)}";

return Identifier(id2);

}

public static string MakeFirstCharUpper(string identifier)

{

var id = identifier;

var id2 = $"{Char.ToUpper(id[0])}{id.Substring(1)}";

return id2;

}

public static SyntaxToken MakeFirstCharLower(SyntaxToken identifier)

{

var id = identifier.ToString();

var id2 = $"{Char.ToLower(id[0])}{id.Substring(1)}";

return Identifier(id2);

}

public static string MakeFirstCharLower(string identifier)

{

var id = identifier;

var id2 = $"{Char.ToLower(id[0])}{id.Substring(1)}";

return id2;

}

static bool FirstCharIsUpper(string name) =>

name.Length > 0 && Char.IsUpper(name[0]);

static HashSet<string> identifiers = new HashSet<string>(new[]

{

"abstract", "as", "base", "bool",

"break", "byte", "case", "catch",

"char", "checked", "class", "const",

"continue", "decimal", "default", "delegate",

"do", "double", "else", "enum",

"event", "explicit", "extern", "false",

"finally", "fixed", "float", "for",

"foreach", "goto", "if", "implicit",

"in", "int", "interface",

"internal", "is", "lock", "long",

"namespace", "new", "null", "object",

"operator", "out", "out", "override",

"params", "private", "protected", "public",

"readonly", "ref", "return", "sbyte",

"sealed", "short", "sizeof", "stackalloc",

"static", "string", "struct", "switch",

"this", "throw", "true", "try",

"typeof", "uint", "ulong", "unchecked",

"unsafe", "ushort", "using","void", "volatile",

"while"

});

static bool IsIdentifier(string id) =>

identifiers.Contains(id.ToLower());

static string MakeCamelCaseId(string id)

{

var id2 = $"{Char.ToLower(id[0])}{id.Substring(1)}";

return IsIdentifier(id2)

? $"@{id2}"

: id2;

}

public static SyntaxToken MakeCamelCaseId(SyntaxToken identifier) =>

Identifier(MakeCamelCaseId(identifier.ToString()));

public static string NextGenName(string gen) =>

$"{gen.Substring(0, gen.Length - 1)}{(char)((gen[gen.Length - 1] + 1))}";

public static ClassDeclarationSyntax AddMembersToPrelude(ClassDeclarationSyntax prelude, StructDeclarationSyntax applyToStruct, string getter, ITypeSymbol symbol)

{

if (symbol == null) return prelude;

var ask = MakeAsk(applyToStruct, getter);

foreach (var member in symbol.GetMembers().Where(m => m.DeclaredAccessibility == Accessibility.Public))

{

switch (member.Kind)

{

case SymbolKind.Field:

var field = (IFieldSymbol)member;

if (applyToStruct.TypeParameterList.Parameters.Count < 2 && !field.IsStatic)

{

var fdecl = CreateFieldOrProperty(applyToStruct, getter, field.Name, field.Type);

prelude = prelude.AddMembers(fdecl);

}

break;

case SymbolKind.Property:

var prop = (IPropertySymbol)member;

if (applyToStruct.TypeParameterList.Parameters.Count < 2 && !prop.IsStatic && prop.Name != "this[]")

{

var fdecl = CreateFieldOrProperty(applyToStruct, getter, prop.Name, prop.Type);

prelude = prelude.AddMembers(fdecl);

}

break;

case SymbolKind.Method:

var method = (IMethodSymbol)member;

if (method.MethodKind == MethodKind.Ordinary &&

method.ReturnType.Name != "Void" &&

!method.IsStatic &&

method.Name != "GetHashCode" &&

method.Name != "Equals" &&

method.Name != "CompareTo" &&

method.Name != "ToString" &&

method.Name != "this" &&

method.Name != "GetEnumerator"

)

{

// Method generics

var generics = TypeParameterList(SeparatedList<TypeParameterSyntax>(method.TypeParameters.Select(a => TypeParameter(a.Name))));

var sparams = applyToStruct.TypeParameterList.Parameters.Count > 0

? applyToStruct.TypeParameterList.Parameters.Take(applyToStruct.TypeParameterList.Parameters.Count - 1).ToList()

: applyToStruct.TypeParameterList.Parameters.ToList();

sparams.AddRange(generics.Parameters);

// Method args

var args = ParameterList(SeparatedList<ParameterSyntax>(

method.Parameters.Select(a => Parameter(Identifier(a.Name)).WithType(ParseTypeName(a.Type.ToString())))));

// Return type

var returnType = MakeGenericStruct(applyToStruct, method.ReturnType.ToString());

// Invocation

var invoke = generics.Parameters.Count == 0

? MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("__env"),

IdentifierName(method.Name))

: MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("__env"),

GenericName(Identifier(method.Name))

.WithTypeArgumentList(

TypeArgumentList(SeparatedList<TypeSyntax>(method.TypeParameters.Select(a => IdentifierName(a.Name))))));

var decl = MethodDeclaration(returnType, method.Name)

.WithModifiers(TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword) }))

.WithParameterList(args)

.WithExpressionBody(

ArrowExpressionClause(

InvocationExpression(ask)

.WithArgumentList(

ArgumentList(

SingletonSeparatedList<ArgumentSyntax>(

Argument(

SimpleLambdaExpression(

Parameter(Identifier("__env")),

InvocationExpression(invoke)

.WithArgumentList(

ArgumentList(

SeparatedList<ArgumentSyntax>(

method.Parameters.Select(a => Argument(IdentifierName(a.Name)))))))))))))

.WithSemicolonToken(

Token(SyntaxKind.SemicolonToken));

decl = sparams.Count == 0

? decl

: decl.WithTypeParameterList(TypeParameterList(SeparatedList<TypeParameterSyntax>(sparams)));

prelude = prelude.AddMembers(decl);

}

break;

}

}

return prelude;

}

static MemberAccessExpressionSyntax MakeAsk(StructDeclarationSyntax applyToStruct, string name)

{

// Ask

return applyToStruct.TypeParameterList.Parameters.Count > 1

? MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

InvocationExpression(

GenericName(Identifier(name))

.WithTypeArgumentList(

TypeArgumentList(

SeparatedList<TypeSyntax>(

applyToStruct.TypeParameterList

.Parameters

.Take(applyToStruct.TypeParameterList.Parameters.Count - 1)

.Select(p => IdentifierName(p.Identifier.ToString())))))),

IdentifierName("Map"))

: MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName(name),

IdentifierName("Map"));

}

static PropertyDeclarationSyntax CreateFieldOrProperty(StructDeclarationSyntax applyToStruct, string getter, string name, ITypeSymbol type)

{

var fdecl = PropertyDeclaration(

MakeGenericStruct(applyToStruct, type.ToString()),

Identifier(name))

.WithModifiers(TokenList(new[] { Token(SyntaxKind.PublicKeyword), Token(SyntaxKind.StaticKeyword) }))

.WithExpressionBody(

ArrowExpressionClause(

InvocationExpression(

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName(getter),

IdentifierName("Map")))

.WithArgumentList(

ArgumentList(

SingletonSeparatedList<ArgumentSyntax>(

Argument(

SimpleLambdaExpression(

Parameter(

Identifier("__env")),

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("__env"),

IdentifierName(name)))))))))

.WithSemicolonToken(

Token(SyntaxKind.SemicolonToken)); ;

return fdecl;

}

public static TypeSyntax MakeGenericStruct(StructDeclarationSyntax s, params string[] genAdd)

{

var nolast = s.TypeParameterList.Parameters.RemoveAt(s.TypeParameterList.Parameters.Count - 1);

var gens = nolast.AddRange(genAdd.Select(gen => TypeParameter(gen)));

return ParseTypeName($"{s.Identifier}<{gens}>");

}

public static TypeSyntax FuncType(params SyntaxNodeOrToken[] gens) =>

SystemType("Func", gens);

public static TypeSyntax FuncType(string gen, params SyntaxNodeOrToken[] gens)

{

var ngens = new SyntaxNodeOrToken[gens.Length + 1];

ngens[0] = IdentifierName(gen);

gens.CopyTo(ngens, 1);

return FuncType(ngens);

}

public static TypeSyntax FuncType(string gen) =>

SystemType("Func", gen);

public static TypeSyntax FuncType(string genA, string genB) =>

SystemType("Func", IdentifierName(genA), IdentifierName(genB));

public static TypeSyntax FuncType(string genA, string genB, string genC) =>

SystemType("Func", IdentifierName(genA), IdentifierName(genB), IdentifierName(genC));

public static TypeSyntax ActionType(params SyntaxNodeOrToken[] gens) =>

SystemType("Action", gens);

public static TypeSyntax ActionType(string gen) =>

SystemType("Action", gen);

public static TypeSyntax SystemType(string name, params SyntaxNodeOrToken[] gens) =>

gens.Length == 0

? QualifiedName(IdentifierName("System"), IdentifierName(name))

: QualifiedName(

IdentifierName("System"),

GenericName(Identifier(name))

.WithTypeArgumentList(TypeArgumentList(SeparatedList<TypeSyntax>(Interleave(gens, Token(SyntaxKind.CommaToken))))));

public static TypeSyntax SystemType(string name, string gen) =>

QualifiedName(

IdentifierName("System"), GenericName(

Identifier(name))

.WithTypeArgumentList(

TypeArgumentList(SingletonSeparatedList<TypeSyntax>(IdentifierName(gen)))));

public static A[] Interleave<A>(A[] xs, A sep)

{

// Ugly, but fast

if (xs.Length == 0) return Array.Empty<A>();

var nxs = new A[xs.Length * 2 - 1];

for(int i = 0; i < nxs.Length; i++)

{

nxs[i] = i % 2 == 0

? xs[i >> 1]

: sep;

}

return nxs;

}

public static MemberAccessExpressionSyntax PreludeMember(SimpleNameSyntax name) =>

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

MemberAccessExpression(

SyntaxKind.SimpleMemberAccessExpression,

IdentifierName("LanguageExt"),

IdentifierName("Prelude")),

name);

public static HashSet<string> MethodNames(SyntaxList<MemberDeclarationSyntax> list) =>

new HashSet<string>(

list.Select(MethodName)

.Where(m => !String.IsNullOrWhiteSpace(m))

.Distinct());

public static HashSet<string> MemberNames(SyntaxList<MemberDeclarationSyntax> list) =>

new HashSet<string>(

list.Select(MemberName)

.Where(m => !String.IsNullOrWhiteSpace(m))

.Distinct());

static string MethodName(MemberDeclarationSyntax decl) =>

decl is MethodDeclarationSyntax m ? m.Identifier.Text : "";

static string MemberName(MemberDeclarationSyntax decl) =>

decl is PropertyDeclarationSyntax p ? p.Identifier.Text

: decl is FieldDeclarationSyntax f ? f.Declaration.Variables[0].Identifier.Text

: decl is MethodDeclarationSyntax m ? m.Identifier.Text

: "";

public static MemberDeclarationSyntax NullIfExists(HashSet<string> members, MemberDeclarationSyntax member) =>

members.Contains(MemberName(member))

? null

: member;

public static List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> MembersWithoutAttr(List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> members, params string[] names) =>

members.Where(p => p.Attrs == null ||

!p.Attrs.Any() ||

!p.Attrs

.SelectMany(a => a.Attributes)

.Select(a => a.Name)

.Select(a => a.ToString())

.Where(names.Contains)

.Any())

.ToList();

public static List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> MembersWithAttr(List<(SyntaxToken Identifier, TypeSyntax Type, SyntaxTokenList Modifiers, SyntaxList<AttributeListSyntax> Attrs)> members, params string[] names) =>

members.Where(p => p.Attrs != null &&

p.Attrs.Any() &&

p.Attrs

.SelectMany(a => a.Attributes)

.Select(a => a.Name)

.Select(a => a.ToString())

.Where(names.Contains)

.Any())

.ToList();

public static MemberDeclarationSyntax[] MakeDataTypeMembers(