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));
}
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 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));
}
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));
}
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));
}
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 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 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));
}
private ArgumentSyntax GetArgumentSyntax(IArgument arg)
{
var expressionSyntax = (ExpressionSyntax)RDom.CSharp.GetSyntaxNode(arg.ValueExpression);
expressionSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(expressionSyntax, arg.Whitespace2Set[LanguageElement.Expression]);
var argSyntax = SyntaxFactory.Argument(expressionSyntax);
argSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirst(argSyntax, arg.Whitespace2Set[LanguageElement.ConstructorInitializerArgument]);
return(argSyntax);
//argSyntax = BuildSyntaxHelpers.AttachWhitespace(argSyntax, arg.Whitespace2Set, WhitespaceLookup);
//argSyntax = BuildSyntaxHelpers.AttachWhitespaceToFirst(argSyntax, arg.Whitespace2Set[LanguageElement.ConstructorInitializerArgument]);
//argSyntax = BuildSyntaxHelpers.AttachWhitespaceToLast(argSyntax, arg.Whitespace2Set[LanguageElement.ParameterLastToken]);
//return (ArgumentSyntax)argSyntax.PrepareForBuildSyntaxOutput(arg).First();
}
private IEnumerable <SyntaxNode> BuildSyntaxLocal(IVariableDeclaration itemAsT, TypeSyntax typeSyntax)
{
var node = SyntaxFactory.VariableDeclarator(itemAsT.Name);
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);
//equalsValueClause = BuildSyntaxHelpers.AttachWhitespace(equalsValueClause, itemAsT.Whitespace2Set, WhitespaceLookup);
node = node.WithInitializer(equalsValueClause);
}
node = BuildSyntaxHelpers.AttachWhitespace(node, itemAsT.Whitespace2Set, WhitespaceLookup);
// Not a statement, so should not call PrepareForBuildSyntaxOutput
return(new SyntaxNode[] { node });
}
protected override SyntaxNode AdjustWhitespace(SyntaxNode node, RDomForStatement item, WhitespaceKindLookup WhitespaceLookup)
{
var itemAsT = item as RDomForStatement;
var syntax = node as ForStatementSyntax;
//var origToken = syntax.FirstSemicolonToken;
//var newToken = BuildSyntaxHelpers.AttachWhitespaceToToken(origToken ,
// item.Whitespace2Set[LanguagePart.Variable, LanguageElement.EndOfLine]);
//syntax = syntax.ReplaceToken(origToken, newToken);
var origNode = syntax.Incrementors.First();
var newNode = BuildSyntaxHelpers.AttachWhitespaceToFirstAndLast(origNode,
item.Whitespace2Set[LanguagePart.Iterator, LanguageElement.Identifier]);
syntax = syntax.ReplaceNode(origNode, newNode);
//origToken = syntax.SecondSemicolonToken;
//newToken = BuildSyntaxHelpers.AttachWhitespaceToToken(origToken,
// item.Whitespace2Set[LanguagePart.Variable, LanguageElement.EndOfLine]);
//syntax = syntax.ReplaceToken(origToken, newToken);
return(syntax);
}
