public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IArgument;
var modifiers = BuildSyntaxHelpers.BuildModfierSyntax(itemAsT);
var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.ValueExpression);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, itemAsT.Whitespace2Set[LanguageElement.Expression]);
var node = SyntaxFactory.Argument(expressionSyntax);
if (itemAsT.IsOut)
{
node = node.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.OutKeyword));
}
else if (itemAsT.IsRef)
{
node = node.WithRefOrOutKeyword(SyntaxFactory.Token(SyntaxKind.RefKeyword));
}
node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, itemAsT.Whitespace2Set[LanguageElement.OutModifier]);
node = BuildSyntaxHelpers.AttachWhitespaceToFirst(node, itemAsT.Whitespace2Set[LanguageElement.RefModifier]);
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));
}
private NamespaceDeclarationSyntax BuidSyntax(INamespace itemAsNamespace, IdentifierNameSyntax identifier)
{
var node = SyntaxFactory.NamespaceDeclaration(identifier);
Guardian.Assert.IsNotNull(itemAsNamespace, nameof(itemAsNamespace));
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsNamespace.Whitespace2Set, WhitespaceLookup);
var usingDirectives = itemAsNamespace.UsingDirectives
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x));
var usingsSyntax = usingDirectives
.OfType <UsingDirectiveSyntax>()
.ToList();
if (usingsSyntax.Count() > 0)
{
node = node.WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(usingsSyntax));
}
var membersSyntax = itemAsNamespace.StemMembers
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <MemberDeclarationSyntax>()
.ToList();
if (membersSyntax.Count() > 0)
{
node = node.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>(membersSyntax));
}
return(node);
}
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));
}
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 T;
SyntaxNode node;
if (itemAsT.Condition == null)
// TODO: Isn't condition null in a ForEach?
{
node = SyntaxFactory.EmptyStatement();
} // This shold not happen
else
{
var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup);
var condition = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Condition);
node = MakeSyntax(itemAsT, condition, statement);
}
var leadingTrivia = BuildSyntaxHelpers.LeadingTrivia(itemAsT, OutputContext);
node = node.WithLeadingTrivia(leadingTrivia);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
node = AdjustWhitespace(node, itemAsT, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(itemAsT, OutputContext));
}
public TypeSyntax GetVariableTypeSyntax(bool isImplicitlyTyped, IReferencedType type)
{
TypeSyntax typeSyntax;
if (isImplicitlyTyped)
{
typeSyntax = SyntaxFactory.ParseTypeName("var");
typeSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(typeSyntax, type.Whitespace2Set.First());
}
else
{
typeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxGroup(type).First();
}
return(typeSyntax);
//if (itemAsVariable.IsImplicitlyTyped)
//{ return SyntaxFactory.IdentifierName("var"); }
//var type = itemAsVariable.Type;
//if (itemAsVariable.IsAliased)
//{
// var typeName = Mappings.AliasFromSystemType(type.Name);
// return SyntaxFactory.IdentifierName(typeName);
//}
//return (TypeSyntax)(RDomCSharp.Factory.BuildSyntax(type));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IInvocationExpression;
if (!string.IsNullOrWhiteSpace(itemAsT.InitialExpressionLanguage) &&
itemAsT.InitialExpressionLanguage != ExpectedLanguages.CSharp)
{
throw new InvalidOperationException();
}
SyntaxNode node;
if (itemAsT.MethodName != null)
{
var methodName = SyntaxFactory.ParseExpression(GetMethodName(itemAsT));
node = SyntaxFactory.ParseExpression(methodName + "()");
var argList = itemAsT.Arguments
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <ArgumentSyntax>()
.ToList();
var argListSyntax = SyntaxFactory.ArgumentList(
SyntaxFactory.SeparatedList(argList));
argListSyntax = BuildSyntaxHelpers.AttachWhitespace(argListSyntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Initializer);
node = (node as InvocationExpressionSyntax).WithArgumentList(argListSyntax);
}
else
{
node = SyntaxFactory.ParseExpression(itemAsT.InitialExpressionString);
}
return(new SyntaxNode[] { node });
}
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));
}
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 IAttributeValue;
var argNameSyntax = SyntaxFactory.IdentifierName(itemAsT.Name);
argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirst(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]);
argNameSyntax = BuildSyntaxHelpers.AttachWhitespaceToLast(argNameSyntax, item.Whitespace2Set[LanguageElement.AttributeValueName]);
//var kind = Mappings.SyntaxKindFromLiteralKind(itemAsT.ValueType, itemAsT.Value);
ExpressionSyntax expr = BuildSyntaxHelpers.BuildArgValueExpression(
itemAsT.Value, itemAsT.ValueConstantIdentifier, itemAsT.ValueType);
var node = SyntaxFactory.AttributeArgument(expr);
if (itemAsT.Style == AttributeValueStyle.Colon)
{
var nameColon = SyntaxFactory.NameColon(argNameSyntax);
nameColon = BuildSyntaxHelpers.AttachWhitespaceToLast(nameColon, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]);
node = node.WithNameColon(nameColon);
}
else if (itemAsT.Style == AttributeValueStyle.Equals)
{
var nameEquals = SyntaxFactory.NameEquals(argNameSyntax);
nameEquals = BuildSyntaxHelpers.AttachWhitespaceToLast(nameEquals, item.Whitespace2Set[LanguageElement.AttributeValueEqualsOrColon]);
node = node.WithNameEquals(nameEquals);
}
node = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(node, item.Whitespace2Set[LanguageElement.AttributeValueValue]);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public static BaseListSyntax GetBaseList(IHasImplementedInterfaces item)
{
var list = new List <BaseTypeSyntax>();
var asClass = item as IClass;
if (asClass != null)
{
if (asClass.BaseType != null)
{
var baseTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(asClass.BaseType);
var baseSyntax = SyntaxFactory.SimpleBaseType(baseTypeSyntax);
list.Add(baseSyntax);
}
}
foreach (var interf in item.ImplementedInterfaces)
{
var interfTypeSyntax = (TypeSyntax)RDom.CSharp.GetSyntaxNode(interf);
var baseSyntax = SyntaxFactory.SimpleBaseType(interfTypeSyntax);
list.Add(baseSyntax);
}
var colonToken = SyntaxFactory.Token(SyntaxKind.ColonToken);
colonToken = BuildSyntaxHelpers.AttachWhitespaceToToken(colonToken, item.Whitespace2Set[LanguageElement.BaseListPrefix]);
return(list.Any()
? SyntaxFactory.BaseList(colonToken, SyntaxFactory.SeparatedList <BaseTypeSyntax>(list))
: null);
}
public static TSyntax BuildTypeParameterSyntax <TSyntax>(IHasTypeParameters itemAsT, TSyntax node,
WhitespaceKindLookup whitespaceLookup,
Func <TSyntax, TypeParameterListSyntax, TSyntax> addTypeParameters,
Func <TSyntax, SyntaxList <TypeParameterConstraintClauseSyntax>, TSyntax> addTypeParameterConstraints)
where TSyntax : SyntaxNode
{
// 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();
var typeParameterSyntaxList = BuildSyntaxHelpers.GetTypeParameterSyntaxList(
typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup);
if (typeParameterSyntaxList != null)
{
node = addTypeParameters(node, typeParameterSyntaxList);
var clauses = BuildSyntaxHelpers.GetTypeParameterConstraintList(
typeParamsAndConstraints, itemAsT.Whitespace2Set, whitespaceLookup);
if (clauses.Any())
{
node = addTypeParameterConstraints(node, clauses);
}
}
return(node);
}
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));
}
public static StatementSyntax BuildStatement(IEnumerable <IStatement> statements,
IStatementBlock parent, WhitespaceKindLookup whitespaceLookup)
{
StatementSyntax statementBlock;
var statementSyntaxList = statements
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.ToList();
var hasBlock = parent.HasBlock;
if (hasBlock || statements.Count() > 1)
{
statementBlock = SyntaxFactory.Block(SyntaxFactory.List(statementSyntaxList));
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
// Block tokens are held in parent
}
else if (statements.Count() == 1)
{
statementBlock = (StatementSyntax)statementSyntaxList.First();
//statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
else
{
statementBlock = SyntaxFactory.EmptyStatement();
statementBlock = BuildSyntaxHelpers.AttachWhitespace(statementBlock, parent.Whitespace2Set, whitespaceLookup);
}
return(statementBlock);
}
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 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));
}
private IEnumerable <SyntaxNode> BuildSyntax(IAttribute item)
{
var itemAsT = item as IAttribute;
var nameSyntax = SyntaxFactory.ParseName(itemAsT.Name);
var node = SyntaxFactory.Attribute(nameSyntax);
node = BuildSyntaxHelpers.AttachWhitespace(node, item.Whitespace2Set, WhitespaceLookup);
var attributeArgList = itemAsT.AttributeValues
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <AttributeArgumentSyntax>()
.ToList();
if (attributeArgList.Any())
{
var argList = SyntaxFactory.AttributeArgumentList(
SyntaxFactory.SeparatedList(attributeArgList));
argList = BuildSyntaxHelpers.AttachWhitespace(argList, item.Whitespace2Set, WhitespaceLookup);
node = node.WithArgumentList(argList);
}
var nodeList = SyntaxFactory.AttributeList(
SyntaxFactory.SeparatedList(
new AttributeSyntax[] {
(AttributeSyntax)BuildSyntaxHelpers.PrepareForBuildItemSyntaxOutput(node, item, OutputContext)
}));
nodeList = BuildSyntaxHelpers.AttachWhitespace(nodeList, item.Whitespace2Set, WhitespaceLookup);
return(nodeList.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IAssignmentStatement;
var leftSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Left);
leftSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(leftSyntax,
itemAsT.Whitespace2Set[LanguageElement.LeftExpression]);
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax,
itemAsT.Whitespace2Set[LanguageElement.Expression]);
var syntaxKind = Mappings.SyntaxKindFromAssignmentOperator(itemAsT.Operator);
var opToken = SyntaxFactory.Token(Mappings.SyntaxTokenKindFromAssignmentOperator(itemAsT.Operator));
opToken = BuildSyntaxHelpers.AttachWhitespaceToToken(opToken, itemAsT.Whitespace2Set[LanguageElement.AssignmentOperator]);
var assignmentSyntax = SyntaxFactory.AssignmentExpression(syntaxKind,
(ExpressionSyntax)leftSyntax,
opToken,
(ExpressionSyntax)expressionSyntax);
assignmentSyntax = BuildSyntaxHelpers.AttachWhitespace(assignmentSyntax, itemAsT.Whitespace2Set, WhitespaceLookup);
var node = SyntaxFactory.ExpressionStatement(assignmentSyntax);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
private SyntaxNode GetConstraintClause(string name, ITypeParameter itemAsT)
{
var list = new List <TypeParameterConstraintSyntax>();
if (itemAsT.HasValueTypeConstraint)
{
list.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.StructConstraint));
}
else if (itemAsT.HasReferenceTypeConstraint)
{
list.Add(SyntaxFactory.ClassOrStructConstraint(SyntaxKind.ClassConstraint));
}
foreach (var typeConstraint in itemAsT.ConstraintTypes)
{
var typeSyntax = (TypeSyntax)RDom.CSharp
.GetSyntaxNode(typeConstraint);
var typeConstraintSyntax = SyntaxFactory.TypeConstraint(typeSyntax);
list.Add(typeConstraintSyntax);
}
// New has to be last
if (itemAsT.HasConstructorConstraint)
{
var constructorConstraint = SyntaxFactory.ConstructorConstraint();
constructorConstraint = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(constructorConstraint, itemAsT.Whitespace2Set[LanguageElement.ConstructorConstraint]);
list.Add(constructorConstraint);
}
var syntax = SyntaxFactory.TypeParameterConstraintClause(name)
.WithConstraints(SyntaxFactory.SeparatedList(list));
syntax = BuildSyntaxHelpers.AttachWhitespace(syntax, itemAsT.Whitespace2Set, WhitespaceLookup, LanguagePart.Constraint);
return(syntax);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsNamespace = item as INamespace;
var identifier = SyntaxFactory.IdentifierName(itemAsNamespace.Name);
var node = SyntaxFactory.NamespaceDeclaration(identifier);
Guardian.Assert.IsNotNull(itemAsNamespace, nameof(itemAsNamespace));
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsNamespace.Whitespace2Set, WhitespaceLookup);
var usingDirectives = itemAsNamespace.UsingDirectives
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x));
var usingsSyntax = usingDirectives
.OfType <UsingDirectiveSyntax>()
.ToList();
if (usingsSyntax.Count() > 0)
{
node = node.WithUsings(SyntaxFactory.List <UsingDirectiveSyntax>(usingsSyntax));
}
var membersSyntax = itemAsNamespace.StemMembers
.SelectMany(x => RDom.CSharp.GetSyntaxGroup(x))
.OfType <MemberDeclarationSyntax>()
.ToList();
if (membersSyntax.Count() > 0)
{
node = node.WithMembers(SyntaxFactory.List <MemberDeclarationSyntax>(membersSyntax));
}
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
private ElseClauseSyntax BuildElseSyntax(IIfStatement itemAsT)
{
// Because we reversed the list, inner is first, inner to outer required for this approach
var elses = itemAsT.Elses.Reverse();
var lastItem = itemAsT;
ElseClauseSyntax elseClause = null;
foreach (var nestedElse in elses)
{
var statement = GetStatement(nestedElse);
var elseIf = nestedElse as IElseIfStatement;
if (elseIf != null)
{
// build if statement and put in else clause
statement = SyntaxFactory.IfStatement(GetCondition(elseIf), statement)
.WithElse(elseClause);
statement = BuildSyntaxHelpers.AttachWhitespace(statement, nestedElse.Whitespace2Set, WhitespaceLookup);
}
var newElseClause = SyntaxFactory.ElseClause(statement);
newElseClause = BuildSyntaxHelpers.AttachWhitespace(newElseClause, nestedElse.Whitespace2Set, WhitespaceLookup);
elseClause = newElseClause;
lastItem = itemAsT;
}
return(elseClause);
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as IContinueStatement;
var node = SyntaxFactory.ContinueStatement();
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
private ExpressionSyntax GetCondition(IHasCondition itemAsT)
{
var expression = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(itemAsT.Condition);
expression = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expression,
itemAsT.Whitespace2Set[LanguageElement.Expression]);
return(expression);
}
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 IInvocationStatement;
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Invocation);
var node = SyntaxFactory.ExpressionStatement((ExpressionSyntax)expressionSyntax);
node = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(node,
itemAsT.Whitespace2Set[LanguageElement.Expression]);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
public override IEnumerable <SyntaxNode> BuildSyntax(IDom item)
{
var itemAsT = item as ILockStatement;
var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup);
var expressionSyntax = RDom.CSharp.GetSyntaxNode(itemAsT.Expression) as ExpressionSyntax;
var node = SyntaxFactory.LockStatement(expressionSyntax, statement);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
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));
}
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 ICheckedStatement;
var statement = RoslynCSharpUtilities.BuildStatement(itemAsT.Statements, itemAsT, WhitespaceLookup) as BlockSyntax;
var kind = itemAsT.Unchecked ? SyntaxKind.UncheckedStatement : SyntaxKind.CheckedStatement;
var node = SyntaxFactory.CheckedStatement(kind, statement);
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
return(node.PrepareForBuildSyntaxOutput(item, OutputContext));
}
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));
}
