private InterfaceDeclarationSyntax addType(PropertyWithName pwn, InterfaceDeclarationSyntax @interface)
{
var method = MethodDeclaration(ParseTypeName($"I{pwn.Type.Name}"), $"Create{pwn.Type.Name}")
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
return @interface.AddMembers(method);
}
protected override CSharpSyntaxGeneratorResult Generate(
InputObjectTypeDescriptor descriptor,
CSharpSyntaxGeneratorSettings settings)
{
string name = NamingConventions.CreateInputValueInfo(descriptor.Name);
InterfaceDeclarationSyntax interfaceDeclaration =
SyntaxFactory.InterfaceDeclaration(name)
.AddModifiers(SyntaxFactory.Token(SyntaxKind.InternalKeyword))
.AddGeneratedAttribute();
foreach (var prop in descriptor.Properties)
{
interfaceDeclaration = interfaceDeclaration.AddMembers(
SyntaxFactory.PropertyDeclaration(
SyntaxFactory.ParseTypeName(TypeNames.Boolean),
NamingConventions.CreateIsSetProperty(prop.Name))
.WithGetter());
}
return(new(
name,
State,
$"{descriptor.RuntimeType.NamespaceWithoutGlobal}.{State}",
interfaceDeclaration));
}
private static InterfaceDeclarationSyntax GenerateInterface(string name, IEnumerable <MethodDeclarationSyntax> methods, BaseListSyntax baseList)
{
InterfaceDeclarationSyntax generatedInterface = SF.InterfaceDeclaration(name).AddModifiers(SF.Token(SyntaxKind.PublicKeyword)).WithBaseList(baseList);
foreach (var method in methods)
{
generatedInterface = generatedInterface.AddMembers(method.WithLeadingTrivia(SF.EndOfLine("")));
}
return(generatedInterface);
}
public override void VisitMethodDeclaration(MethodDeclarationSyntax node)
{
var parameters = node.ParameterList.Parameters.ToArray();
var typeParameters = node.TypeParameterList.Parameters.ToArray();
@interface = @interface.AddMembers(
Syntax.MethodDeclaration(node.ReturnType, node.Identifier.ToString())
.AddParameterListParameters(parameters)
.AddTypeParameterListParameters(typeParameters));
// More code to add members to the classes too.
}
private InterfaceDeclarationSyntax CreateMethod(
InterfaceDeclarationSyntax interfaceDeclaration,
GraphQLFieldDefinition field,
IEnumerable <ASTNode> allDefinitions,
TypeSyntax returnType,
string methodName)
{
var method = SyntaxFactory.MethodDeclaration(returnType, methodName)
.AddAttributeLists(GetFieldAttributes(field))
.WithParameterList(this.GetParameterList(field.Arguments, allDefinitions))
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
return(interfaceDeclaration.AddMembers(method));
}
private InterfaceDeclarationSyntax GenerateProperty(
string interfaceTypeName,
InterfaceDeclarationSyntax interfaceDeclaration,
GraphQLFieldDefinition field,
IEnumerable <ASTNode> allDefinitions)
{
var member = SyntaxFactory.PropertyDeclaration(
this.GetCSharpTypeFromGraphQLType(field.Type, allDefinitions),
PickFieldName(interfaceTypeName, field, allDefinitions))
.AddAttributeLists(GetFieldAttributes(field))
.AddAccessorListAccessors(
SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)),
SyntaxFactory.AccessorDeclaration(SyntaxKind.SetAccessorDeclaration)
.WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken)));
return(interfaceDeclaration.AddMembers(member));
}
public void Generate(xcb xcb, string name)
{
InterfaceDeclarationSyntax ids = InterfaceDeclaration("I" + name);
foreach (@request req in xcb.Items.Where(r => r is @request).Cast <@request>())
{
ids = ids.AddMembers(GenFunction(req, name));
}
CompilationUnitSyntax cu = CompilationUnit().
AddUsings(UsingDirective(IdentifierName("System"))).
WithMembers(SingletonList <MemberDeclarationSyntax>(ids)).
NormalizeWhitespace();
using (FileStream fs = new FileStream(name + "Iface.cs", FileMode.Create))
using (TextWriter tw = new StreamWriter(fs))
{
cu.WriteTo(tw);
}
}
private static InterfaceDeclarationSyntax DecorateInterfaceWithWrapperFunction(
MethodDeclarationSyntax methodDeclaration,
IdentifierNameSyntax invokeMethodIdentifier,
InterfaceDeclarationSyntax interfaceDeclaration)
{
if (interfaceDeclaration.Members
.OfType<MethodDeclarationSyntax>()
.Any(x => x.Identifier.Text == invokeMethodIdentifier.Identifier.Text))
{
return interfaceDeclaration;
}
var dllImport = methodDeclaration.AttributeLists
.First(x => x.OpenBracketToken.HasLeadingTrivia);
var interfaceMethodDeclaration = SyntaxFactory.MethodDeclaration(
SyntaxFactory.List(new[] {
GetCompilerGeneratedAttribute()
.WithTrailingTrivia(
NewLineCharacter,
TabCharacter)
}),
GetModifiersForWrapperFunction(methodDeclaration),
methodDeclaration.ReturnType,
default(ExplicitInterfaceSpecifierSyntax),
invokeMethodIdentifier.Identifier,
methodDeclaration.TypeParameterList,
methodDeclaration.ParameterList,
methodDeclaration.ConstraintClauses,
default(BlockSyntax),
SyntaxFactory.Token(SyntaxKind.SemicolonToken));
interfaceDeclaration = interfaceDeclaration
.AddMembers(
interfaceMethodDeclaration
.WithTrailingTrivia(
NewLineCharacter,
TabCharacter)
.WithLeadingTrivia(dllImport.OpenBracketToken.LeadingTrivia));
return interfaceDeclaration;
}
public static InterfaceDeclarationSyntax AddProperty(this InterfaceDeclarationSyntax node, string typeName,
string identifier)
{
return(node.AddMembers(MakeProperty(typeName, identifier, p => p.WithModifiers(new SyntaxTokenList()))));
}
