public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IConversionOperator;
var kind = itemAsT.IsImplicit ? SyntaxKind.ImplicitKeyword : SyntaxKind.ExplicitKeyword;
var opToken = SyntaxFactory.Token(kind);
var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.Type).First();
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var node = SyntaxFactory.ConversionOperatorDeclaration(opToken, typeSyntax)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
//node = node.WithLeadingTrivia(BuildSyntaxHelpers.LeadingTrivia(item));
var parameterList = itemAsT.Parameters
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <ParameterSyntax>()
.ToList();
var parameterListSyntax = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList));
parameterListSyntax = BuildSyntaxHelpers.AttachWhitespace(parameterListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithParameterList(parameterListSyntax);
node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup));
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IEnumMember;
Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT));
var identifier = SyntaxFactory.Identifier(itemAsT.Name);
var node = SyntaxFactory.EnumMemberDeclaration(identifier);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
if (itemAsT.Expression != null)
{
if (itemAsT.Expression.InitialExpressionLanguage != ExpectedLanguages.CSharp)
{
throw new InvalidOperationException();
}
var exprSyntax = SyntaxFactory.ParseExpression(itemAsT.Expression.InitialExpressionString);
var equalsValueSyntax = SyntaxFactory.EqualsValueClause(exprSyntax);
equalsValueSyntax = BuildSyntaxHelpers.AttachWhitespace(equalsValueSyntax, item.Whitespace2Set, WhitespaceLookup);
node = node.WithEqualsValue(equalsValueSyntax);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup);
//node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, item.Whitespace2Set[LanguageElement.EnumValueFirstToken]);
//node = BuildSyntaxHelpers.AttachWhitespaceToLast(node, item.Whitespace2Set[LanguageElement.EnumValueLastToken]);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IEvent;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.Type).First();
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var variableNode = SyntaxFactory.VariableDeclarator(nameSyntax);
var variableNodes = SyntaxFactory.SeparatedList(new VariableDeclaratorSyntax[] { variableNode });
var eventNode = SyntaxFactory.VariableDeclaration(typeSyntax, variableNodes);
eventNode = BuildSyntaxHelpers.AttachWhitespace(eventNode, itemAsT.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.EventFieldDeclaration(eventNode)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IUsingStatement;
var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup);
var node = SyntaxFactory.UsingStatement(statement);
if (itemAsT.Variable != null)
{
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Variable.Initializer);
var equalsValueClause = SyntaxFactory.EqualsValueClause((ExpressionSyntax)expressionSyntax);
equalsValueClause = BuildSyntaxHelpers.AttachWhitespace(equalsValueClause, itemAsT.Variable.Whitespace2Set, WhitespaceLookup);
var nodeDeclarator = SyntaxFactory.VariableDeclarator(itemAsT.Variable.Name);
nodeDeclarator = nodeDeclarator.WithInitializer(equalsValueClause);
nodeDeclarator = BuildSyntaxHelpers.AttachWhitespace(nodeDeclarator, itemAsT.Variable.Whitespace2Set, WhitespaceLookup);
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { (VariableDeclaratorSyntax)nodeDeclarator }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
node = node.WithDeclaration(nodeDeclaration);
}
else
{
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression) as ExpressionSyntax;
node = node.WithExpression(expressionSyntax);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
private IEnumerable <CatchClauseSyntax> BuildCatchSyntaxList(ITryStatement itemAsT)
{
var ret = new List <CatchClauseSyntax>();
foreach (var ctch in itemAsT.Catches)
{
var syntax = SyntaxFactory.CatchClause();
if (ctch.ExceptionType != null)
{
TypeSyntax typeSyntax = (TypeSyntax)(RDom.CSharp.GetSyntaxNode(ctch.ExceptionType));
var declaration = SyntaxFactory.CatchDeclaration(typeSyntax);
if (ctch.Variable != null)
{
declaration = declaration.WithIdentifier(SyntaxFactory.Identifier(ctch.Variable.Name));
}
declaration = BuildSyntaxHelpers.AttachWhitespace(declaration, ctch.Whitespace2Set, WhitespaceLookup);
syntax = syntax.WithDeclaration(declaration);
}
// TODO: Add catch filter for 6.0
// TODO: Empty statement would return empty brackets here?
var block = BuildSyntaxWorker.GetStatementBlock(ctch.Statements);
block = BuildSyntaxHelpers.AttachWhitespace(block, ctch.Whitespace2Set, WhitespaceLookup);
syntax = syntax.WithBlock(block);
syntax = BuildSyntaxHelpers.AttachWhitespace(syntax, ctch.Whitespace2Set, WhitespaceLookup);
ret.Add(syntax);
}
return(ret);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IDeclarationStatement;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.IsImplicitlyTyped, itemAsT.Type);
var variable = item as IVariableDeclaration;
// This is a weakness in the current factory lookup - we can't just ask for a random factory
// so to call the normal build syntax through the factory causes infinite recursion.
// TODO: Add the ability to request a random factory from the container (via the CSharp uber factory
var tempFactory = new RDomVariableDeclarationFactory(OutputContext.Corporation);
var nodeDeclarators = tempFactory.BuildSyntax(item);
var nodeDeclarator = (VariableDeclaratorSyntax)nodeDeclarators.First();
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(
SyntaxFactory.List <VariableDeclaratorSyntax>(
new VariableDeclaratorSyntax[]
{ nodeDeclarator }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.LocalDeclarationStatement(nodeDeclaration);
if (itemAsT.IsConst)
{
node = node.WithModifiers(SyntaxFactory.TokenList(SyntaxFactory.Token(SyntaxKind.ConstKeyword)));
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
protected override ForStatementSyntax MakeSyntax(RDomForStatement itemAsT, ExpressionSyntax condition, StatementSyntax statementBlock)
{
var declaratorSyntax = (VariableDeclaratorSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Variable);
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
var nodeDeclaratorInList = SyntaxFactory.SeparatedList(SyntaxFactory.List <VariableDeclaratorSyntax>(new VariableDeclaratorSyntax[] { declaratorSyntax }));
var nodeDeclaration = SyntaxFactory.VariableDeclaration(typeSyntax, nodeDeclaratorInList);
nodeDeclaration = BuildSyntaxHelpers.AttachWhitespace(nodeDeclaration, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Variable);
var incrementorSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Incrementor);
incrementorSyntax = BuildSyntaxHelpers.AttachWhitespace(incrementorSyntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Iterator);
var secondSemiColonToken = SyntaxFactory.Token(SyntaxKind.SemicolonToken);
secondSemiColonToken = triviaManager.AttachWhitespaceToToken(secondSemiColonToken, itemAsT.Whitespace2Set[LanguagePart.Condition, LanguageElement.EndOfLine]);
var node = SyntaxFactory.ForStatement(statementBlock)
.WithCondition(condition)
.WithDeclaration(nodeDeclaration)
.WithIncrementors(SyntaxFactory.SeparatedList <ExpressionSyntax>(new ExpressionSyntax[] { (ExpressionSyntax)incrementorSyntax }))
.WithSecondSemicolonToken(secondSemiColonToken);
return(node);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IBlockStatement;
var block = BuildSyntaxWorker.GetStatementBlock(itemAsT.Statements);
var node = SyntaxFactory.Block(SyntaxFactory.List(block.Statements));
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IParameter;
Guardian.Assert.IsNotNull(itemAsT, nameof(itemAsT));
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var syntaxType = (TypeSyntax)(RDom.CSharp.GetSyntaxNode(itemAsT.Type));
syntaxType = BuildSyntaxHelpers.RemoveLeadingSpaces(syntaxType);
var node = SyntaxFactory.Parameter(nameSyntax)
.WithType(syntaxType);
if (itemAsT.DefaultValueType != LiteralKind.Unknown)
{
var defaultValueExpression = BuildSyntaxHelpers.BuildArgValueExpression(
itemAsT.DefaultValue, itemAsT.DefaultConstantIdentifier, itemAsT.DefaultValueType);
var defaultClause = SyntaxFactory.EqualsValueClause(defaultValueExpression);
defaultClause = BuildSyntaxHelpers.AttachWhitespace(defaultClause, item.Whitespace2Set, WhitespaceLookup);
node = node.WithDefault(defaultClause);
}
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var modifiers = SyntaxFactory.TokenList();
if (itemAsT.IsOut)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.OutKeyword));
}
if (itemAsT.IsRef)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.RefKeyword));
}
if (itemAsT.IsParamArray)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ParamsKeyword));
}
if (modifiers.Any())
{
node = node.WithModifiers(modifiers);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup);
node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, item.Whitespace2Set[LanguageElement.ParameterFirstToken]);
node = BuildSyntaxHelpers.AttachWhitespaceToLast(node, item.Whitespace2Set[LanguageElement.ParameterLastToken]);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
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));
}
protected override ForEachStatementSyntax MakeSyntax(
RDomForEachStatement itemAsT, ExpressionSyntax condition, StatementSyntax statementBlock)
{
var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(
itemAsT.Variable.IsImplicitlyTyped, itemAsT.Variable.Type);
//var typeSyntax = BuildSyntaxWorker.GetVariableTypeSyntax(itemAsT.Variable);
//typeSyntax = BuildSyntaxHelpers.AttachWhitespace(typeSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
var id = itemAsT.Variable.Name;
return(SyntaxFactory.ForEachStatement(typeSyntax, id, condition, statementBlock));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IConstructor;
var parent = item.Parent as IClass;
SyntaxToken nameSyntax;
if (parent == null)
{
nameSyntax = SyntaxFactory.Identifier("unknown_name");
}
else
{
nameSyntax = SyntaxFactory.Identifier(parent.Name);
}
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var node = SyntaxFactory.ConstructorDeclaration(nameSyntax)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var parameterList = itemAsT.Parameters
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <ParameterSyntax>()
.ToList();
var parameterListSyntax = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList));
parameterListSyntax = BuildSyntaxHelpers.AttachWhitespace(parameterListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithParameterList(parameterListSyntax);
//node = node.WithLeadingTrivia(BuildSyntaxHelpers.LeadingTrivia(item));
node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup));
var initializer = BuildInitializer(itemAsT);
if (initializer != null)
{
initializer = BuildSyntaxHelpers.AttachWhitespace(initializer,
itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Initializer);
node = node.WithInitializer(initializer);
}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
private FinallyClauseSyntax BuildFinallySyntax(ITryStatement itemAsT)
{
var fnally = itemAsT.Finally;
// TODO: Empty statement would return empty brackets here?
var block = BuildSyntaxWorker.GetStatementBlock(fnally.Statements);
block = BuildSyntaxHelpers.AttachWhitespace(block, fnally.Whitespace2Set, WhitespaceLookup);
var syntax = SyntaxFactory.FinallyClause(block);
syntax = BuildSyntaxHelpers.AttachWhitespace(syntax, fnally.Whitespace2Set, WhitespaceLookup);
return(syntax);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IField;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var returnTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.ReturnType).First();
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
if (itemAsT.IsReadOnly)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ReadOnlyKeyword));
}
if (itemAsT.IsConstant)
{
modifiers = modifiers.Remove(modifiers.Where(x => x.Kind() == SyntaxKind.StaticKeyword).First());
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.ConstKeyword));
}
if (itemAsT.IsVolatile)
{
modifiers = modifiers.Add(SyntaxFactory.Token(SyntaxKind.VolatileKeyword));
}
var declaratorNode = SyntaxFactory.VariableDeclarator(nameSyntax);
if (itemAsT.Initializer != null)
{
var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Initializer);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]);
var equalsToken = SyntaxFactory.Token(SyntaxKind.EqualsToken);
equalsToken = BuildSyntaxHelpers.AttachWhitespaceToToken(equalsToken, itemAsT.Whitespace2Set[LanguageElement.EqualsAssignmentOperator]);
var equalsValueClause = SyntaxFactory.EqualsValueClause(equalsToken, expressionSyntax);
declaratorNode = declaratorNode.WithInitializer(equalsValueClause);
}
declaratorNode = BuildSyntaxHelpers.AttachWhitespace(declaratorNode, itemAsT.Whitespace2Set, WhitespaceLookup);
var variableNode = SyntaxFactory.VariableDeclaration(returnTypeSyntax)
.WithVariables(
SyntaxFactory.SingletonSeparatedList(declaratorNode));
//variableNode = BuildSyntaxHelpers.AttachWhitespace(variableNode, itemAsField.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.FieldDeclaration(variableNode)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as ITryStatement;
var node = SyntaxFactory.TryStatement();
var catches = BuildCatchSyntaxList(itemAsT);
var fnally = BuildFinallySyntax(itemAsT);
var block = BuildSyntaxWorker.GetStatementBlock(itemAsT.Statements);
block = BuildSyntaxHelpers.AttachWhitespace(block, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithCatches(SyntaxFactory.List(catches))
.WithFinally(fnally)
.WithBlock(block);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IProperty;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var returnType = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.ReturnType).First();
var node = SyntaxFactory.PropertyDeclaration(returnType, nameSyntax);
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
node = node.WithModifiers(modifiers);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var accessors = SyntaxFactory.List <AccessorDeclarationSyntax>();
var getAccessorSyntax = RDom.CSharp.GetSyntaxGroup(itemAsT.GetAccessor).FirstOrDefault();
if (getAccessorSyntax != null)
{
accessors = accessors.Add((AccessorDeclarationSyntax)getAccessorSyntax);
}
var setAccessorSyntax = RDom.CSharp.GetSyntaxGroup(itemAsT.SetAccessor).FirstOrDefault();
if (setAccessorSyntax != null)
{
accessors = accessors.Add((AccessorDeclarationSyntax)setAccessorSyntax);
}
var accessorList = SyntaxFactory.AccessorList(accessors);
accessorList = BuildSyntaxHelpers.AttachWhitespace(accessorList, itemAsT.Whitespace2Set, WhitespaceLookup);
if (accessors.Any())
{
node = node.WithAccessorList(accessorList);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
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));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IDestructor;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var node = SyntaxFactory.DestructorDeclaration(nameSyntax)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
//node = node.WithLeadingTrivia(BuildSyntaxHelpers.LeadingTrivia(item));
node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup));
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IMethod;
var nameSyntax = SyntaxFactory.Identifier(itemAsT.Name);
var returnTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(itemAsT.ReturnType).First();
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var node = SyntaxFactory.MethodDeclaration(returnTypeSyntax, nameSyntax)
.WithModifiers(modifiers);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
var attributes = BuildSyntaxWorker.BuildAttributeSyntax(itemAsT.Attributes);
if (attributes.Any())
{
node = node.WithAttributeLists(BuildSyntaxHelpers.WrapInAttributeList(attributes));
}
var parameterList = itemAsT.Parameters
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <ParameterSyntax>()
.ToList();
if (itemAsT.IsExtensionMethod)
{
// this this is a normal list, ref semantics
var firstParam = parameterList.FirstOrDefault();
parameterList.Remove(firstParam);
if (firstParam == null)
{
throw new InvalidOperationException("Extension methods must have at least one parameter");
}
// I'm cheating a bit here. Since the This keyword is an indicator of extension state on the method
// I'm hardcoding a single space. I don't see the complexity of dealing with this as worth it unless
// there's gnashing of teeth over this single space. The use of "this" on the parameter is not universal
// and VB marks the method.
var thisModifier = SyntaxFactory.Token(SyntaxKind.ThisKeyword)
.WithTrailingTrivia(SyntaxFactory.ParseTrailingTrivia(" "));
var paramModifiers = firstParam.Modifiers.Insert(0, thisModifier);
firstParam = firstParam.WithModifiers(paramModifiers);
parameterList.Insert(0, firstParam);
}
var parameterListSyntax = SyntaxFactory.ParameterList(SyntaxFactory.SeparatedList(parameterList));
parameterListSyntax = BuildSyntaxHelpers.AttachWhitespace(parameterListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithParameterList(parameterListSyntax);
node = node.WithBody((BlockSyntax)RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup));
// This works oddly because it uncollapses the list
// This code is largely repeated in interface and class factories, but is very hard to refactor because of shallow Roslyn (Microsoft) architecture
var typeParamsAndConstraints = itemAsT.TypeParameters
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.ToList();
node = BuildSyntaxHelpers.BuildTypeParameterSyntax(
itemAsT, node, WhitespaceLookup,
(x, p) => x.WithTypeParameterList(p),
(x, c) => x.WithConstraintClauses(c));
//var typeParameterSyntaxList = BuildSyntaxHelpers.GetTypeParameterSyntaxList(
// typeParamsAndConstraints, itemAsT.Whitespace2Set, WhitespaceLookup);
//if (typeParameterSyntaxList != null)
//{
// node = node.WithTypeParameterList(typeParameterSyntaxList);
// var clauses = BuildSyntaxHelpers.GetTypeParameterConstraintList(
// typeParamsAndConstraints, itemAsT.Whitespace2Set, WhitespaceLookup);
// if (clauses.Any())
// { node = node.WithConstraintClauses(clauses); }
//}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
