static ClassDeclarationSyntax AddImplicitEvents(this ClassDeclarationSyntax proxyClass, ProxySyntaxInfo proxyInfo)
{
// Events
proxyClass = proxyClass
.AddMembers(proxyInfo.ImplicitEvents.Select(e =>
EventDeclaration(
ToSyntax(e.Type),
Identifier(e.Name))
.WithPublicModifier()
.WithAccessorList(
AccessorList(
List(new AccessorDeclarationSyntax[] {
AccessorDeclaration(
SyntaxKind.AddAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(e.AddMethod.ReturnType, e.AddMethod.Parameters)))
.WithSemicolon(),
AccessorDeclaration(
SyntaxKind.RemoveAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(e.RemoveMethod.ReturnType, e.RemoveMethod.Parameters)))
.WithSemicolon()
})))).ToArray());
return(proxyClass);
}
public static ClassDeclarationSyntax AddImplementation(this ClassDeclarationSyntax proxyClass, ProxySyntaxInfo proxyInfo)
{
return(proxyClass
.AddImplicitEvents(proxyInfo)
.AddImplicitProperties(proxyInfo)
.AddImplicitIndexers(proxyInfo)
.AddImplicitMethods(proxyInfo));
}
static ClassDeclarationSyntax AddImplicitIndexers(this ClassDeclarationSyntax proxyClass, ProxySyntaxInfo proxyInfo)
{
foreach (var i in proxyInfo.ImplicitProperties.Where(p => p.IsIndexer))
{
var indexer = IndexerDeclaration(ToSyntax(i.Type))
.WithPublicModifier()
.WithParameterList(
BracketedParameterList()
.AddParameters(i.Parameters.Select(p =>
Parameter(Identifier(p.Name))
.WithType(ToSyntax(p.Type))).ToArray()));
if (i.GetMethod != null)
{
indexer = indexer.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(i.Type, i.GetMethod.Parameters)))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)));
}
if (i.SetMethod != null)
{
indexer = indexer.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(i.Type, i.SetMethod.Parameters)))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)));
}
proxyClass = proxyClass.AddMembers(indexer);
}
return(proxyClass);
}
static ClassDeclarationSyntax AddImplicitMethods(this ClassDeclarationSyntax proxyClass, ProxySyntaxInfo proxyInfo)
{
foreach (var m in proxyInfo.ImplicitMethods.Where(m => m.CanBeReferencedByName && (m.IsVirtual || m.IsAbstract)))
{
var method = MethodDeclaration(m.ReturnType.ToSyntax(), m.Name).WithPublicModifier();
var outParams = new List <IParameterSymbol>();
var refOutParams = new List <IParameterSymbol>();
foreach (var p in m.Parameters)
{
var parameter = Parameter(Identifier(p.Name));
switch (p.RefKind)
{
case RefKind.Ref:
parameter = parameter.WithModifiers(TokenList(Token(SyntaxKind.RefKeyword)));
refOutParams.Add(p);
break;
case RefKind.Out:
parameter = parameter.WithModifiers(TokenList(Token(SyntaxKind.OutKeyword)));
outParams.Add(p);
refOutParams.Add(p);
break;
case RefKind.None:
default:
break;
}
method = method.AddParameterListParameters(parameter.WithType(ToSyntax(p.Type)));
}
if (outParams.Count != 0 || refOutParams.Count != 0)
{
var statements = new List <StatementSyntax>(
outParams.Select(p => ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(p.Name),
DefaultExpression(p.Type.ToSyntax()))))
);
statements.Add(
LocalDeclarationStatement(
VariableDeclaration(
IdentifierName("var"))
.WithVariables(
SingletonSeparatedList(
VariableDeclarator(
Identifier("returns"))
.WithInitializer(
EqualsValueClause(InvokePipeline(null, m.Parameters)))))));
statements.AddRange(refOutParams.Select(p =>
ExpressionStatement(
AssignmentExpression(
SyntaxKind.SimpleAssignmentExpression,
IdentifierName(p.Name),
CastExpression(
p.Type.ToSyntax(),
ElementAccessExpression(
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("returns"),
IdentifierName("Outputs")))
.WithArgumentList(
BracketedArgumentList(
SingletonSeparatedList <ArgumentSyntax>(
Argument(
LiteralExpression(
SyntaxKind.StringLiteralExpression,
Literal(p.Name))))))))))
);
if (!m.ReturnsVoid)
{
statements.Add(
ReturnStatement(
CastExpression(
method.ReturnType,
MemberAccessExpression(
SyntaxKind.SimpleMemberAccessExpression,
IdentifierName("returns"),
IdentifierName("ReturnValue"))))
);
}
method = method.WithBody(Block(statements));
}
else
{
method = method
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(m.ReturnType, m.Parameters)))
.WithSemicolonToken(Token(SyntaxKind.SemicolonToken));
}
proxyClass = proxyClass.AddMembers(method);
}
return(proxyClass);
}
static ClassDeclarationSyntax AddImplicitProperties(this ClassDeclarationSyntax proxyClass, ProxySyntaxInfo proxyInfo)
{
foreach (var prop in proxyInfo.ImplicitProperties.Where(p => !p.IsIndexer))
{
var property =
PropertyDeclaration(
ToSyntax(prop.Type),
Identifier(prop.Name))
.WithPublicModifier();
if (prop.GetMethod != null)
{
property = property.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.GetAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(prop.Type, prop.GetMethod.Parameters)))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)));
}
if (prop.SetMethod != null)
{
property = property.AddAccessorListAccessors(
AccessorDeclaration(
SyntaxKind.SetAccessorDeclaration)
.WithExpressionBody(
ArrowExpressionClause(InvokePipeline(prop.Type, prop.SetMethod.Parameters)))
.WithSemicolonToken(
Token(SyntaxKind.SemicolonToken)));
}
proxyClass = proxyClass.AddMembers(property);
}
return(proxyClass);
}
