public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IClass;
Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT));
var modifiers = item.BuildModfierSyntax();
if (itemAsT.IsAbstract)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.AbstractKeyword));
}
if (itemAsT.IsSealed)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.SealedKeyword));
}
if (itemAsT.IsPartial)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.PartialKeyword));
}
var identifier = SyntaxFactory.Identifier(itemAsT.Name);
var node = SyntaxFactory.ClassDeclaration(identifier)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, whitespaceLookup);
var baseList = BuildSyntaxHelpers.GetBaseList(itemAsT);
if (baseList != null)
{
node = node.WithBaseList(baseList);
}
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var membersSyntax = itemAsT.Members
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.ToList();
node = node.WithMembers(SyntaxFactory.List(membersSyntax));
node = BuildSyntaxHelpers.BuildTypeParameterSyntax(
itemAsT, node, whitespaceLookup,
(x, p) => x.WithTypeParameterList(p),
(x, c) => x.WithConstraintClauses(c));
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IAccessor;
var parentProperty = item.Parent as RDomProperty; // .NET specific
if (itemAsT == null || parentProperty == null)
{
throw new InvalidOperationException();
}
var kind = (itemAsT.AccessorType == AccessorType.Get)
? SyntaxKind.GetAccessorDeclaration : SyntaxKind.SetAccessorDeclaration;
AccessorDeclarationSyntax node;
if (itemAsT.Statements.Any() || !parentProperty.CanBeAutoProperty)
{
var statementBlock = (BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup);
node = SyntaxFactory.AccessorDeclaration(kind, statementBlock);
}
else
{
node = SyntaxFactory.AccessorDeclaration(kind).WithSemicolonToken(
SyntaxFactory.Token(
SyntaxKind.SemicolonToken));
}
if (itemAsT.AccessModifier != parentProperty.AccessModifier)
{
var modifiers = item.BuildModfierSyntax();
node = node.WithModifiers(modifiers);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributeList = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributeList.Any())
{
node = node.WithAttributeLists(attributeList);
}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IEnum;
Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT));
var modifiers = item.BuildModfierSyntax();
var identifier = SyntaxFactory.Identifier(itemAsT.Name);
var node = SyntaxFactory.EnumDeclaration(identifier)
.WithModifiers(modifiers);
var baseList = GetBaseList(itemAsT);
if (baseList != null)
{
node = node.WithBaseList(baseList);
}
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var memberList = itemAsT.Members
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <EnumMemberDeclarationSyntax>()
.ToList();
if (memberList.Any())
{
var memberListSyntax = SyntaxFactory.SeparatedList(memberList);
node = node.WithMembers(memberListSyntax);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, whitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
